ironweave 1.1.2 → 1.1.3

package/.cursor/rules/ironweave.mdc

@@ -0,0 +1,12 @@
+---
+description: Ironweave skills framework — orchestration, requirements, architecture, TDD, and quality gates
+alwaysApply: true
+---
+
+# Ironweave
+
+You have access to the Ironweave skills library — a complete software development workflow with built-in quality gates.
+
+The **orchestrator** skill (`skills/orchestrator/SKILL.md`) is the main entry point. For any development task, start by reading it. The orchestrator automatically senses context, scores difficulty, selects the right route, and runs Plan → Execute → Validate → Deliver with quality gates.
+
+All skills are in `skills/`, each with a `SKILL.md` containing instructions.

package/{.windsurfrules → .windsurf/rules/ironweave.md}

@@ -1,3 +1,7 @@
+---
+trigger: always_on
+---
+
 # Ironweave
 
 You have access to the Ironweave skills library — a complete software development workflow with built-in quality gates.

package/bin/cli.js

@@ -16,7 +16,7 @@ Usage:
 
 Options:
   --agent <name>    Only install config for specific agent
-                    (claude, copilot, cursor, windsurf, cline, codex, gemini, all)
+                    (claude, copilot, cursor, windsurf, cline, trae, codex, gemini, all)
                     Default: all
   --lang <lang>     Language for skills: zh (Chinese, default) or en (English)
   --skills-only     Only copy skills/, skip agent config files
@@ -66,29 +66,28 @@ if (command === 'init') {
   if (!skillsOnly) {
     const agentFiles = {
       claude: [
-        { src: 'CLAUDE.md', dst: 'CLAUDE.md' },
-        { src: '.claude-plugin', dst: '.claude-plugin', dir: true }
+        { src: 'CLAUDE.md', dst: 'CLAUDE.md' }
       ],
       copilot: [
         { src: '.github/copilot-instructions.md', dst: '.github/copilot-instructions.md' }
       ],
       cursor: [
-        { src: '.cursorrules', dst: '.cursorrules' },
-        { src: '.cursor-plugin', dst: '.cursor-plugin', dir: true }
+        { src: '.cursor/rules', dst: '.cursor/rules', dir: true }
       ],
       windsurf: [
-        { src: '.windsurfrules', dst: '.windsurfrules' }
+        { src: '.windsurf/rules', dst: '.windsurf/rules', dir: true }
       ],
       cline: [
-        { src: '.clinerules', dst: '.clinerules' }
+        { src: '.clinerules', dst: '.clinerules', dir: true }
+      ],
+      trae: [
+        { src: '.trae/rules', dst: '.trae/rules', dir: true }
       ],
       codex: [
-        { src: 'AGENTS.md', dst: 'AGENTS.md' },
-        { src: '.codex', dst: '.codex', dir: true }
+        { src: 'AGENTS.md', dst: 'AGENTS.md' }
       ],
       gemini: [
-        { src: 'GEMINI.md', dst: 'GEMINI.md' },
-        { src: 'gemini-extension.json', dst: 'gemini-extension.json' }
+        { src: 'GEMINI.md', dst: 'GEMINI.md' }
       ]
     };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ironweave",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Agentic skills framework for AI coding agents — orchestrated workflows with adaptive routing, quality gates, and 17 composable skills.",
   "keywords": [
     "agent-skills",
@@ -38,15 +38,11 @@
     "CLAUDE.md",
     "AGENTS.md",
     "GEMINI.md",
-    "gemini-extension.json",
-    ".cursorrules",
-    ".windsurfrules",
-    ".clinerules",
+    ".cursor/",
+    ".windsurf/",
+    ".clinerules/",
+    ".trae/",
     ".github/",
-    ".claude-plugin/",
-    ".cursor-plugin/",
-    ".codex/",
-    ".opencode/",
     "README.md",
     "README_CN.md",
     "CONTRIBUTING.md",

package/skills/integration-test-design/SKILL.md

@@ -33,6 +33,21 @@ graph TB
 
 ---
 
+## 0. TDD 适用性判断
+
+在设计测试策略之前，根据项目成熟度决定 TDD 的应用范围：
+
+| 项目状态 | TDD 策略 | 原因 |
+|--|--|--|
+| 新项目（从零开始） | **全面 TDD** — 所有新代码先写测试 | 成本最低、收益最高，测试基础设施一次搭好 |
+| 成熟项目 — 已有代码 | **不追溯补测试** | ROI 太低，除非该模块即将重构 |
+| 成熟项目 — 新增/修改代码 | **新代码用 TDD** | 唯一低成本引入安全网的机会，渐进式提升覆盖率 |
+| Bug 修复 | **必须写回归测试** | 回归测试是 bug fix 的核心产出，防止复现 |
+
+> **原则**：不在遗留代码上做无意义的补测试运动，但每次改动都带测试，几个月后覆盖率自然上来。
+
+---
+
 ## 1. 识别集成点
 
 从时序设计中提取所有跨层/跨模块调用，标记测试级别：

package/skills/orchestrator/SKILL.md

@@ -1,14 +1,23 @@
 ---
 name: orchestrator
 description: >-
-  项目开发全生命周期的流程编排器。接收用户输入后，自动感知项目上下文、评估任务难度、选择最优路径，编排 Plan→Execute→Validate→Deliver 四阶段并管理质量卡点和失败回流。
+  项目开发全生命周期的流程编排器。接收用户输入后，先做输入分类（4 档），自适应感知项目上下文、评估任务难度、选择最优路径，编排 Plan→Execute→Validate→Deliver 四阶段并管理质量卡点和失败回流。
   务必在以下场景使用本 skill：用户要开始一个新项目、接到一个新需求、要做一次完整的开发迭代、要从需求到交付走一遍完整流程，或者用户说"开始做"、"启动项目"、"这个需求怎么落地"、"帮我规划一下"、"从头到尾做一遍"。
   当用户的意图是完成一个端到端的开发任务（而不是只做其中某一步），使用本 skill 来编排整个流程。如果用户只需要其中某一步（如只写需求文档），直接使用对应的专项 skill。
 ---
 
 # Orchestrator — 流程编排器
 
-接收用户输入 → 感知上下文 → 评估难度 → **宏观澄清**（按需）→ **范围切片** → 选路径 → 逐 slice 编排四阶段 → 质量卡点 → 交付。
+接收用户输入 → **输入分类** → 自适应上下文感知 → 评估难度 → **宏观澄清**（按需）→ **范围切片** → 选路径 → 逐 slice 编排四阶段 → 质量卡点 → 交付。
+
+---
+
+## 全局约束
+
+以下两条规则贯穿所有阶段和 skill，不可豁免：
+
+1. **证据锚定**：每个设计决策必须引用至少一条**项目上下文事实**作为依据。禁止仅用“业界最佳实践”或“通常建议”作为唯一理由。如果项目上下文中找不到支撑证据，必须明确标注“**假设**”。
+2. **反向质疑**：推荐架构方案、技术选型或设计模式后，必须回答：**如果这个方案是错的，最可能的原因是什么？** 如果无法回答，说明理解不够深入，需要补充上下文。
 
 ---
 
@@ -16,9 +25,10 @@ description: >-
 
 ```mermaid
 graph TB
-    INPUT["用户输入"] --> CTX["上下文感知<br>project-context"]
+    INPUT["用户输入"] --> CLASS["输入分类<br>4 维度分析"]
+    CLASS --> CTX["自适应上下文感知<br>project-context"]
     CTX --> SCORE["难度评估<br>task-difficulty"]
-    SCORE --> NEED_CL{"需求模糊<br>OR L4+?"}
+    SCORE --> NEED_CL{"分类=Grand<br>OR 需求模糊<br>OR L4+?"}
     NEED_CL -->|"是"| CLARIFY["宏观澄清<br>requirement-qa(scope模式)<br>+ brainstorm(L4+)"]
     NEED_CL -->|"否"| SLICE
     CLARIFY --> SLICE["范围切片<br>scope-sizer"]
@@ -39,6 +49,7 @@ graph TB
     NEXT -->|"否"| DONE["全部完成"]
 
     style INPUT fill:#e8eaf6,stroke:#283593,color:#1a237e,stroke-width:2px
+    style CLASS fill:#ede7f6,stroke:#4527a0,color:#311b92,stroke-width:2px
     style CTX fill:#e3f2fd,stroke:#1565c0,color:#0d47a1
     style SCORE fill:#e3f2fd,stroke:#1565c0,color:#0d47a1
     style NEED_CL fill:#fff3e0,stroke:#e65100,color:#bf360c
@@ -55,13 +66,94 @@ graph TB
 
 ---
 
-## 1. 上下文感知
+## 0. 输入分类（Input Classification）
+
+在触碰任何 skill 之前，仅基于**用户输入文本**做 4 维度分析，产出分类结果，驱动后续所有步骤选择适当的深度。
+
+### 4 维度评估
+
+| 维度 | 说明 | 低 → 高 |
+|------|------|---------|
+| **具体性** (Concreteness) | 用户指向的目标有多精确 | 具体文件/函数 → 某个模块 → 某个系统 → 宏观愿景 |
+| **范围广度** (Scope Breadth) | 隐含涉及多少模块 | 单点 → 单模块 → 多模块 → 全系统 |
+| **决策负载** (Decision Load) | 是否需要架构/策略层面的决策 | 无 → 少量 → 显著 → 关键 |
+| **模糊度** (Ambiguity) | 还有多少东西未定义 | 全清晰 → 部分缺口 → 大量缺口 → 几乎未定义 |
 
-用 project-context 获取项目信息，判定项目类型：
+### 4 档分类
+
+```mermaid
+graph TB
+    INPUT["用户输入文本"] --> DIM["4 维度评估<br>具体性 / 范围 / 决策 / 模糊度"]
+    DIM --> C1{"高具体 + 窄范围<br>+ 无决策 + 清晰?"}
+    C1 -->|"是"| PIN["Pinpoint 针对性"]
+    C1 -->|"否"| C2{"中等具体 + 有界<br>+ 少量决策 + 部分清晰?"}
+    C2 -->|"是"| BND["Bounded 有边界"]
+    C2 -->|"否"| C3{"抽象 + 宽范围<br>+ 有决策 + 有缺口?"}
+    C3 -->|"是"| CPX["Complex 复合型"]
+    C3 -->|"否"| GRD["Grand 宏大型"]
+
+    style INPUT fill:#e8eaf6,stroke:#283593,color:#1a237e,stroke-width:2px
+    style DIM fill:#ede7f6,stroke:#4527a0,color:#311b92
+    style PIN fill:#e8f5e9,stroke:#2e7d32,color:#1b5e20
+    style BND fill:#fff9c4,stroke:#f9a825,color:#e65100
+    style CPX fill:#ffe0b2,stroke:#e65100,color:#bf360c
+    style GRD fill:#ffcdd2,stroke:#c62828,color:#b71c1c
+```
+
+| 分类 | 典型输入 | Context 策略 | 难度提示 | CLARIFY |
+|------|---------|-------------|---------|---------|
+| **Pinpoint** | "GET /api/users/123 返回 500"<br>"把登录按钮颜色改成蓝色" | **point-trace** | L1-L2 | 跳过 |
+| **Bounded** | "给 user 模块加修改密码功能"<br>"优化订单列表的查询性能" | **focused-scan** | L2-L3 | 按需 |
+| **Complex** | "增加支付模块，要对接微信和支付宝"<br>"把单体拆成前后端分离" | **broad-scan** | L3-L4 | 按需 |
+| **Grand** | "做一个类似淘宝的电商平台"<br>"设计一个分布式事务框架" | **full-scan** | L4-L5 | **强制** |
+
+### 用户覆盖
+
+用户可在任何时刻用自然语言覆盖分类："简单处理" → 降档，"认真做" → 升档。
+
+---
+
+## 1. 自适应上下文感知
+
+根据输入分类结果，用 project-context 的**对应模式**获取项目信息。
+
+### 4 种 Context 模式
+
+| 模式 | 触发分类 | 做什么 | 产出 |
+|------|---------|--------|------|
+| **point-trace** | Pinpoint | 定位用户提及的目标点（文件/函数/错误） → 追溯 import/caller 依赖 → 检查同模块边界 | 目标点 + 直接关联文件列表 + 局部架构 |
+| **focused-scan** | Bounded | 扫描目标模块 + 相邻模块 + 接口边界 | 目标模块详情 + 邻居模块概要 + API 边界 |
+| **broad-scan** | Complex | 扫描全项目架构 + 模块关系 + 技术栈 | 完整项目结构 + 模块关系图 + 技术栈概要 |
+| **full-scan** | Grand | 完整项目扫描（如果有代码仓库） + 领域分析 | 完整项目上下文 + 架构全貌 + 领域分析 |
+
+```mermaid
+graph TB
+    CLASS["输入分类结果"] --> MODE{"分类档位"}
+    MODE -->|"Pinpoint"| PT["point-trace<br>定位目标 → 追溯依赖链"]
+    MODE -->|"Bounded"| FS["focused-scan<br>目标模块 + 相邻模块"]
+    MODE -->|"Complex"| BS["broad-scan<br>全项目架构 + 模块关系"]
+    MODE -->|"Grand"| FULL["full-scan<br>完整扫描 + 领域分析"]
+
+    PT --> TYPE["判定项目类型"]
+    FS --> TYPE
+    BS --> TYPE
+    FULL --> TYPE
+
+    style CLASS fill:#ede7f6,stroke:#4527a0,color:#311b92,stroke-width:2px
+    style PT fill:#e8f5e9,stroke:#2e7d32,color:#1b5e20
+    style FS fill:#fff9c4,stroke:#f9a825,color:#e65100
+    style BS fill:#ffe0b2,stroke:#e65100,color:#bf360c
+    style FULL fill:#ffcdd2,stroke:#c62828,color:#b71c1c
+    style TYPE fill:#e3f2fd,stroke:#1565c0,color:#0d47a1
+```
+
+### 项目类型判定
+
+上下文感知完成后，判定项目类型（与分类无关，所有模式都做）：
 
 ```mermaid
 graph LR
-    CTX_START["project-context"] --> HAS_CODE{"有代码仓库?"}
+    CTX_START["上下文感知完成"] --> HAS_CODE{"有代码仓库?"}
     HAS_CODE -->|"无/空/仅脚手架"| NEW["A: 新项目"]
     HAS_CODE -->|"有完整代码"| INTENT{"用户意图?"}
     INTENT -->|"错误或异常"| BUG["C: Bug 修复"]
@@ -98,6 +190,7 @@ graph LR
 
 | 条件 | 判定依据 |
 |------|---------|
+| 输入分类为 Grand | 输入分类阶段已判定为宏大型 — **强制触发** |
 | 需求模糊/宽泛 | 用户输入未明确列出功能模块或具体范围 |
 | 难度 L4+ | task-difficulty 评分 ≥ 7，架构方向会影响切片方式 |
 
@@ -105,6 +198,7 @@ graph LR
 
 | 条件 | 示例 |
 |------|------|
+| 输入分类为 Pinpoint 或 Bounded | 已在分类阶段确认目标具体、范围有界 |
 | 需求已经具体 | "在 user 模块加修改密码 API"、"GET /api/novels/123 返回 500" |
 | 难度 L1-L3 | 简单任务，天然范围窄 |
 
@@ -208,6 +302,15 @@ graph TB
 - **后续 slice**：Plan 阶段跳过全局性 skill，只执行 slice 级 skill（requirement-qa 针对本 slice 功能、spec-writing 只写本 slice 文档、api-contract-design 只做增量端点）
 - **slice 间传递**：前一个 slice 的 Deliver 产出（docs/ + .cache/context.db）是后续 slice 的 Plan 输入
 
+### 上下文窗口管理
+
+Plan 阶段的顺序 skill 链会在上下文窗口中累积大量中间产出。为防止窗口溢出导致注意力衰减，遵循以下规则：
+
+- **落盘即释放**：每个 skill 产出写入 docs/ 后，后续 skill 不应依赖窗口中"记住"的全文。需要引用前置产出时，**从文件读取**而非依赖窗口记忆
+- **只保留摘要**：在窗口中仅保留每个 skill 的产出摘要（核心结论、关键决策、模块清单），完整文档查阅 docs/
+- **Slice 边界是重置点**：进入新 Slice 时，从 docs/ + .cache/context.db 加载所需上下文，而非试图"记住"前一个 Slice 的全部内容
+- **按需加载 SKILL.md**：每个 skill 的 SKILL.md 在调用该 skill 时读取，使用完毕后其详细指令不需要在窗口中持续保留
+
 ### Plan
 
 读取命中的 route-{x}.md，按其中的 skill 编排执行 Plan。

package/skills/orchestrator/references/parallel.md

@@ -68,3 +68,23 @@ graph TB
 - 仅用于无需 AI 介入的 CLI 工具（安装、编译、测试执行、lint）
 - 启动后主线程继续编写下一模块，稍后检查后台输出
 - 后台进程失败不阻塞主线程，但结果需在 Validate 卡点前确认
+
+## SubAgent 降级策略
+
+当 Agent 宿主环境不支持 SubAgent（或 SubAgent 能力有限）时，所有 SubAgent 场景**退回主 Agent 串行执行**。架构设计保证不依赖 SubAgent 的并行性——SubAgent 是性能优化，不是功能前提。
+
+### 降级映射
+
+| SubAgent 场景 | 正常模式 | 降级模式 |
+|--------------|---------|---------|
+| brainstorm 多角色 | 6 个 SubAgent 并行扮演不同角色 | 主 Agent 依次扮演每个角色，串行输出各视角分析 |
+| A+ Plan 三件套 | 3 个 SubAgent 并行（performance + complexity + observability） | 主 Agent 串行依次执行三个 skill |
+| + 变体 Execute | 每个 task 由 fresh SubAgent 隔离执行 | 主 Agent 按 task 串行执行，在 task 间自行做上下文分隔（明确标注："--- Task N 开始 ---"） |
+| Deliver 双写 | 2 个 SubAgent 并行（docs-output + project-context） | 主 Agent 先执行 docs-output，再执行 project-context |
+
+### 降级检测
+
+模型在首次需要 SubAgent 时检测宿主环境：
+- 如果宿主提供 SubAgent/fork/spawn 能力 → 使用 SubAgent 模式
+- 如果不提供 → 切换到降级模式，后续同一会话不再重复检测
+- 降级不影响质量卡点——Plan Gate / Validate Gate 的检查规则完全一致

package/skills/project-context/SKILL.md

@@ -41,6 +41,52 @@ graph TD
 
 ## 核心能力（被动 API）
 
+### 0. 上下文模式选择
+
+被 orchestrator 调用时，根据输入分类结果选择对应的上下文获取模式：
+
+| 模式 | 说明 | 扫描范围 | 产出 |
+|------|------|---------|------|
+| **point-trace** | 先定位再扩散 | 用户提及的目标点 → 追溯 import/caller → 同模块文件 | 目标点 + 直接关联文件 + 局部依赖链 |
+| **focused-scan** | 聚焦模块 | 目标模块全量 + 相邻模块概要 + API 边界 | 模块详情 + 邻居概要 + 接口边界 |
+| **broad-scan** | 广域扫描 | 全项目文件树 + 模块间依赖 + 技术栈 | 完整结构 + 模块关系 + 技术栈 |
+| **full-scan** | 全量深度扫描 | 全项目 + 代码摘要 + 领域分析 | 完整上下文 + 架构全貌 |
+
+```mermaid
+graph TB
+    MODE{"上下文模式"} --> PT["point-trace<br>定位目标点"]
+    MODE --> FS["focused-scan<br>目标模块 + 邻居"]
+    MODE --> BS["broad-scan<br>全项目结构"]
+    MODE --> FULL["full-scan<br>全量深度"]
+
+    PT --> PT1["1. 根据用户输入定位目标文件/函数"]
+    PT1 --> PT2["2. 追溯 import/export 依赖链"]
+    PT2 --> PT3["3. 检查同模块内关联文件"]
+    PT3 --> PT4["4. 产出局部上下文"]
+
+    FS --> FS1["1. 识别目标模块目录"]
+    FS1 --> FS2["2. 扫描模块内全部文件"]
+    FS2 --> FS3["3. 识别相邻模块 + 接口边界"]
+    FS3 --> FS4["4. 产出模块级上下文"]
+
+    BS --> BS1["1. 扫描全项目文件树"]
+    BS1 --> BS2["2. 识别模块间依赖关系"]
+    BS2 --> BS3["3. 检测技术栈和构建配置"]
+    BS3 --> BS4["4. 产出项目级上下文"]
+
+    FULL --> FULL1["1. 全项目文件树 + 代码摘要"]
+    FULL1 --> FULL2["2. 模块关系 + 领域模型"]
+    FULL2 --> FULL3["3. 技术栈 + 架构模式识别"]
+    FULL3 --> FULL4["4. 产出完整上下文"]
+
+    style PT fill:#e8f5e9,stroke:#2e7d32,color:#1b5e20
+    style FS fill:#fff9c4,stroke:#f9a825,color:#e65100
+    style BS fill:#ffe0b2,stroke:#e65100,color:#bf360c
+    style FULL fill:#ffcdd2,stroke:#c62828,color:#b71c1c
+```
+
+未被 orchestrator 调用时（独立使用），默认执行 broad-scan 模式。
+
 ### 1. init — 初始化
 
 首次在项目中使用时调用。扫描项目文件结构，生成初始快照。

package/skills/task-difficulty/SKILL.md

@@ -16,6 +16,7 @@ description: >-
 ```mermaid
 graph LR
     INPUT["用户输入<br/>任务描述"]
+    CLASS["输入分类提示<br/>Pinpoint/Bounded/<br>Complex/Grand"]
     CTX["上下文追溯<br/>涉及的文件·模块·依赖"]
     SCORE["多维度评分<br/>5个维度 × 1-5分"]
     LEVEL["难度分级<br/>L1-L5"]
@@ -24,15 +25,29 @@ graph LR
     OUT_BUMP["上浮一级"]
     RESULT["输出<br/>难度报告"]
 
-    INPUT --> CTX --> SCORE --> LEVEL --> THROTTLE
+    INPUT --> CLASS --> CTX --> SCORE --> LEVEL --> THROTTLE
     THROTTLE -->|"是，L1证据充分"| OUT_KEEP --> RESULT
     THROTTLE -->|"否，存在不确定性"| OUT_BUMP --> RESULT
 
     style INPUT fill:#e3f2fd,stroke:#1976d2
+    style CLASS fill:#ede7f6,stroke:#4527a0,color:#311b92
     style THROTTLE fill:#fff3e0,stroke:#f57c00,stroke-width:2px
     style RESULT fill:#e8f5e9,stroke:#388e3c
 ```
 
+### 输入分类提示
+
+被 orchestrator 调用时，接收输入分类结果作为评分校准参考（不替代评分）：
+
+| 输入分类 | 分数预期范围 | 说明 |
+|---------|------------|------|
+| Pinpoint | L1-L2 (1-4) | 分类提示为低难度区间，但评分仍可能突破（如目标点涉及复杂依赖链） |
+| Bounded | L2-L3 (2-6) | 分类提示为中低区间 |
+| Complex | L3-L4 (4-8) | 分类提示为中高区间 |
+| Grand | L4-L5 (7-10) | 分类提示为高难度区间 |
+
+如果实际评分与分类提示的预期范围偏差 > 2 级，须在难度报告中标注偏差原因。
+
 ## 难度等级
 
 | 等级 | 名称 | 典型特征 | 示例 |

package/skills-en/integration-test-design/SKILL.md

@@ -33,6 +33,21 @@ graph TB
 
 ---
 
+## 0. TDD Applicability by Project Maturity
+
+Before designing test strategy, determine TDD scope based on project maturity:
+
+| Project State | TDD Strategy | Rationale |
+|--|--|--|
+| New project (greenfield) | **Full TDD** — all new code gets tests first | Lowest cost, highest ROI; test infrastructure set up once |
+| Mature project — existing code | **Don't backfill tests** | ROI too low, unless the module is about to be refactored |
+| Mature project — new/modified code | **TDD for new code** | Only low-cost opportunity to introduce a safety net; coverage improves incrementally |
+| Bug fixes | **Regression test required** | Regression test is the core deliverable of a bug fix |
+
+> **Principle**: Don't launch a pointless test-backfilling campaign on legacy code. Instead, bring tests with every change — coverage will naturally improve over months.
+
+---
+
 ## 1. Identify Integration Points
 
 Extract all cross-layer/cross-module calls from sequence design, marking test levels:

package/skills-en/orchestrator/SKILL.md

@@ -1,14 +1,23 @@
 ---
 name: orchestrator
 description: >-
-  Full-lifecycle flow orchestrator for project development. Upon receiving user input, it automatically senses project context, scores task difficulty, selects the optimal route, and orchestrates the Plan→Execute→Validate→Deliver four-phase pipeline with quality gates and failure reflow.
+  Full-lifecycle flow orchestrator for project development. Upon receiving user input, it first classifies the input (4 tiers), then adaptively senses project context, scores task difficulty, selects the optimal route, and orchestrates the Plan→Execute→Validate→Deliver four-phase pipeline with quality gates and failure reflow.
   Use this skill when: the user wants to start a new project, receives a new requirement, needs a full development iteration, wants to go through the complete flow from requirements to delivery, or says things like "start building", "launch the project", "how to implement this requirement", "help me plan this", "do it end-to-end".
   When the user's intent is to complete an end-to-end development task (rather than just one step), use this skill to orchestrate the entire flow. If the user only needs a specific step (e.g., just write requirement docs), use the corresponding specialized skill directly.
 ---
 
 # Orchestrator — Flow Orchestrator
 
-Receive user input → Sense context → Score difficulty → **Macro-level clarification** (if needed) → **Scope slicing** → Select route → Orchestrate four phases per slice → Quality gates → Deliver.
+Receive user input → **Input Classification** → Adaptive context sensing → Score difficulty → **Macro clarification** (if needed) → **Scope slicing** → Select route → Orchestrate four phases per slice → Quality gates → Deliver.
+
+---
+
+## Global Constraints
+
+The following two rules apply across all phases and skills, no exceptions:
+
+1. **Evidence Anchoring**: Every design decision must cite at least one **project context fact** as justification. Using only "industry best practice" or "generally recommended" as the sole rationale is prohibited. If no supporting evidence exists in the project context, it must be explicitly marked as "**Assumption**".
+2. **Reverse Challenge**: After recommending an architecture, technology choice, or design pattern, you must answer: **If this recommendation is wrong, what is the most likely reason?** If you cannot answer, your understanding is insufficient — gather more context before proceeding.
 
 ---
 
@@ -16,9 +25,10 @@ Receive user input → Sense context → Score difficulty → **Macro-level clar
 
 ```mermaid
 graph TB
-    INPUT["User Input"] --> CTX["Context Sensing<br>project-context"]
+    INPUT["User Input"] --> CLASS["Input Classification<br>4-Dimension Analysis"]
+    CLASS --> CTX["Adaptive Context Sensing<br>project-context"]
     CTX --> SCORE["Difficulty Scoring<br>task-difficulty"]
-    SCORE --> NEED_CL{"Requirements ambiguous<br>OR L4+?"}
+    SCORE --> NEED_CL{"Classification=Grand<br>OR ambiguous<br>OR L4+?"}
     NEED_CL -->|"Yes"| CLARIFY["Macro Clarification<br>requirement-qa(scope mode)<br>+ brainstorm(L4+)"]
     NEED_CL -->|"No"| SLICE
     CLARIFY --> SLICE["Scope Slicing<br>scope-sizer"]
@@ -39,6 +49,7 @@ graph TB
     NEXT -->|"No"| DONE["All Complete"]
 
     style INPUT fill:#e8eaf6,stroke:#283593,color:#1a237e,stroke-width:2px
+    style CLASS fill:#ede7f6,stroke:#4527a0,color:#311b92,stroke-width:2px
     style CTX fill:#e3f2fd,stroke:#1565c0,color:#0d47a1
     style SCORE fill:#e3f2fd,stroke:#1565c0,color:#0d47a1
     style NEED_CL fill:#fff3e0,stroke:#e65100,color:#bf360c
@@ -55,13 +66,94 @@ graph TB
 
 ---
 
-## 1. Context Sensing
+## 0. Input Classification
+
+Before touching any skill, perform a 4-dimension analysis based solely on the **user's input text**, producing a classification result that drives all subsequent steps to choose the appropriate depth.
+
+### 4-Dimension Assessment
+
+| Dimension | Description | Low → High |
+|-----------|-------------|------------|
+| **Concreteness** | How precisely does the user point to a target | Specific file/function → A module → A system → Macro vision |
+| **Scope Breadth** | How many modules are implicitly involved | Single point → Single module → Multi-module → Full system |
+| **Decision Load** | Are architectural/strategic decisions required | None → Minor → Significant → Critical |
+| **Ambiguity** | How much is still undefined | Fully clear → Some gaps → Major gaps → Mostly undefined |
+
+### 4-Tier Classification
+
+```mermaid
+graph TB
+    INPUT["User Input Text"] --> DIM["4-Dimension Assessment<br>Concreteness / Scope / Decision / Ambiguity"]
+    DIM --> C1{"High concrete + Narrow<br>+ No decision + Clear?"}
+    C1 -->|"Yes"| PIN["Pinpoint"]
+    C1 -->|"No"| C2{"Medium concrete + Bounded<br>+ Minor decision + Partially clear?"}
+    C2 -->|"Yes"| BND["Bounded"]
+    C2 -->|"No"| C3{"Abstract + Wide<br>+ Decisions needed + Gaps?"}
+    C3 -->|"Yes"| CPX["Complex"]
+    C3 -->|"No"| GRD["Grand"]
+
+    style INPUT fill:#e8eaf6,stroke:#283593,color:#1a237e,stroke-width:2px
+    style DIM fill:#ede7f6,stroke:#4527a0,color:#311b92
+    style PIN fill:#e8f5e9,stroke:#2e7d32,color:#1b5e20
+    style BND fill:#fff9c4,stroke:#f9a825,color:#e65100
+    style CPX fill:#ffe0b2,stroke:#e65100,color:#bf360c
+    style GRD fill:#ffcdd2,stroke:#c62828,color:#b71c1c
+```
+
+| Classification | Typical Input | Context Strategy | Difficulty Hint | CLARIFY |
+|---------------|---------------|-----------------|----------------|---------|
+| **Pinpoint** | "GET /api/users/123 returns 500"<br>"Change login button color to blue" | **point-trace** | L1-L2 | Skip |
+| **Bounded** | "Add change-password feature to user module"<br>"Optimize order list query performance" | **focused-scan** | L2-L3 | As needed |
+| **Complex** | "Add payment module integrating WeChat Pay and Alipay"<br>"Split monolith into frontend-backend separation" | **broad-scan** | L3-L4 | As needed |
+| **Grand** | "Build an e-commerce platform like Amazon"<br>"Design a distributed transaction framework" | **full-scan** | L4-L5 | **Mandatory** |
+
+### User Override
+
+Users can override the classification at any time with natural language: "keep it simple" → downgrade, "do it thoroughly" → upgrade.
+
+---
+
+## 1. Adaptive Context Sensing
+
+Based on the input classification result, use project-context's **corresponding mode** to gather project information.
+
+### 4 Context Modes
+
+| Mode | Triggered By | What It Does | Output |
+|------|-------------|-------------|--------|
+| **point-trace** | Pinpoint | Locate the target point (file/function/error) mentioned by user → trace import/caller dependencies → check same-module boundaries | Target point + directly related files + local dependency chain |
+| **focused-scan** | Bounded | Scan target module + neighboring modules + interface boundaries | Target module details + neighbor summaries + API boundaries |
+| **broad-scan** | Complex | Scan full project architecture + module relationships + tech stack | Complete project structure + module relationship map + tech stack summary |
+| **full-scan** | Grand | Full project scan (if code repo exists) + domain analysis | Complete project context + architectural overview + domain analysis |
 
-Use project-context to gather project information and determine project type:
+```mermaid
+graph TB
+    CLASS["Classification Result"] --> MODE{"Classification Tier"}
+    MODE -->|"Pinpoint"| PT["point-trace<br>Locate target, trace dependencies"]
+    MODE -->|"Bounded"| FS["focused-scan<br>Target module + neighbors"]
+    MODE -->|"Complex"| BS["broad-scan<br>Full project architecture"]
+    MODE -->|"Grand"| FULL["full-scan<br>Complete deep scan"]
+
+    PT --> TYPE["Determine Project Type"]
+    FS --> TYPE
+    BS --> TYPE
+    FULL --> TYPE
+
+    style CLASS fill:#ede7f6,stroke:#4527a0,color:#311b92,stroke-width:2px
+    style PT fill:#e8f5e9,stroke:#2e7d32,color:#1b5e20
+    style FS fill:#fff9c4,stroke:#f9a825,color:#e65100
+    style BS fill:#ffe0b2,stroke:#e65100,color:#bf360c
+    style FULL fill:#ffcdd2,stroke:#c62828,color:#b71c1c
+    style TYPE fill:#e3f2fd,stroke:#1565c0,color:#0d47a1
+```
+
+### Project Type Determination
+
+After context sensing completes, determine project type (regardless of classification — all modes do this):
 
 ```mermaid
 graph LR
-    CTX_START["project-context"] --> HAS_CODE{"Has code repo?"}
+    CTX_START["Context Sensing Complete"] --> HAS_CODE{"Has code repo?"}
     HAS_CODE -->|"None/Empty/Scaffold only"| NEW["A: New Project"]
     HAS_CODE -->|"Has substantial code"| INTENT{"User intent?"}
     INTENT -->|"Error or anomaly"| BUG["C: Bug Fix"]
@@ -98,6 +190,7 @@ After difficulty scoring and before scope slicing, determine whether the require
 
 | Condition | Criteria |
 |-----------|---------|
+| Input classified as Grand | Already determined as Grand type in classification phase — **mandatory trigger** |
 | Vague/broad requirements | User input doesn't explicitly list feature modules or specific scope |
 | Difficulty L4+ | task-difficulty score ≥ 7, architectural direction affects slicing approach |
 
@@ -105,6 +198,7 @@ After difficulty scoring and before scope slicing, determine whether the require
 
 | Condition | Example |
 |-----------|---------|
+| Input classified as Pinpoint or Bounded | Already confirmed specific target and bounded scope in classification phase |
 | Requirements already specific | "Add a change-password API to the user module", "GET /api/novels/123 returns 500" |
 | Difficulty L1-L3 | Simple tasks, naturally narrow scope |
 
@@ -208,6 +302,15 @@ When multiple slices exist, execute them sequentially by dependency order. Each
 - **Subsequent slices**: Plan phase skips global skills, only executes slice-level skills (requirement-qa targeting this slice's features, spec-writing only for this slice's docs, api-contract-design only for incremental endpoints)
 - **Inter-slice handoff**: Previous slice's Deliver output (docs/ + .cache/context.db) becomes the next slice's Plan input
 
+### Context Window Management
+
+The Plan phase's sequential skill chain accumulates substantial intermediate output in the context window. To prevent window overflow and attention degradation, follow these rules:
+
+- **Persist then release**: After each skill's output is written to docs/, subsequent skills should NOT rely on the full text being "remembered" in the window. When referencing prior output, **read from files** instead of relying on window memory
+- **Keep only summaries**: Retain only each skill's output summary in the window (core conclusions, key decisions, module list); consult docs/ for full documents
+- **Slice boundaries are reset points**: When entering a new Slice, load required context from docs/ + .cache/context.db rather than trying to "remember" everything from the previous Slice
+- **Load SKILL.md on demand**: Each skill's SKILL.md is read when that skill is invoked; its detailed instructions do not need to persist in the window after use
+
 ### Plan
 
 Read the matched route-{x}.md and execute Plan following its skill orchestration.

package/skills-en/orchestrator/references/parallel.md

@@ -68,3 +68,23 @@ Used only in + variant Execute phase. Detailed rules -> read `references/execute
 - Only for CLI tools requiring no AI involvement (install, compile, test execution, lint)
 - After launching, main thread continues writing next module, checks background output later
 - Background process failure doesn't block main thread, but results must be confirmed before Validate gate
+
+## SubAgent Degradation Strategy
+
+When the agent host environment does not support SubAgents (or has limited SubAgent capability), all SubAgent scenarios **fall back to main Agent sequential execution**. The architecture is designed to never depend on SubAgent parallelism — SubAgents are a performance optimization, not a functional prerequisite.
+
+### Degradation Mapping
+
+| SubAgent Scenario | Normal Mode | Degraded Mode |
+|-------------------|-------------|---------------|
+| brainstorm multi-role | 6 SubAgents in parallel playing different roles | Main Agent plays each role sequentially, outputting each perspective's analysis in turn |
+| A+ Plan triple-skill | 3 SubAgents in parallel (performance + complexity + observability) | Main Agent executes all three skills sequentially |
+| + variant Execute | Each task by fresh SubAgent with context isolation | Main Agent executes tasks sequentially, self-separating context between tasks (explicitly marking: "--- Task N Start ---") |
+| Deliver dual-write | 2 SubAgents in parallel (docs-output + project-context) | Main Agent executes docs-output first, then project-context |
+
+### Degradation Detection
+
+The model detects the host environment when SubAgents are first needed:
+- If the host provides SubAgent/fork/spawn capability → use SubAgent mode
+- If not → switch to degraded mode; do not re-detect within the same session
+- Degradation does not affect quality gates — Plan Gate / Validate Gate checks remain identical

package/skills-en/project-context/SKILL.md

@@ -41,6 +41,52 @@ graph TD
 
 ## Core Capabilities (Passive API)
 
+### 0. Context Mode Selection
+
+When called by the orchestrator, selects the corresponding context acquisition mode based on the input classification result:
+
+| Mode | Description | Scan Scope | Output |
+|------|-------------|-----------|--------|
+| **point-trace** | Locate first, then expand | Target point mentioned by user → trace import/caller → same-module files | Target point + directly related files + local dependency chain |
+| **focused-scan** | Focus on module | Target module full scan + neighboring module summaries + API boundaries | Module details + neighbor summaries + interface boundaries |
+| **broad-scan** | Wide-area scan | Full project file tree + inter-module dependencies + tech stack | Complete structure + module relationships + tech stack |
+| **full-scan** | Full deep scan | Full project + code summaries + domain analysis | Complete context + architectural overview |
+
+```mermaid
+graph TB
+    MODE{"Context Mode"} --> PT["point-trace<br>Locate target point"]
+    MODE --> FS["focused-scan<br>Target module + neighbors"]
+    MODE --> BS["broad-scan<br>Full project structure"]
+    MODE --> FULL["full-scan<br>Full depth"]
+
+    PT --> PT1["1. Locate target file/function from user input"]
+    PT1 --> PT2["2. Trace import/export dependency chain"]
+    PT2 --> PT3["3. Check related files within same module"]
+    PT3 --> PT4["4. Output local context"]
+
+    FS --> FS1["1. Identify target module directory"]
+    FS1 --> FS2["2. Scan all files within module"]
+    FS2 --> FS3["3. Identify neighboring modules + interface boundaries"]
+    FS3 --> FS4["4. Output module-level context"]
+
+    BS --> BS1["1. Scan full project file tree"]
+    BS1 --> BS2["2. Identify inter-module dependency relationships"]
+    BS2 --> BS3["3. Detect tech stack and build configuration"]
+    BS3 --> BS4["4. Output project-level context"]
+
+    FULL --> FULL1["1. Full project file tree + code summaries"]
+    FULL1 --> FULL2["2. Module relationships + domain model"]
+    FULL2 --> FULL3["3. Tech stack + architectural pattern recognition"]
+    FULL3 --> FULL4["4. Output complete context"]
+
+    style PT fill:#e8f5e9,stroke:#2e7d32,color:#1b5e20
+    style FS fill:#fff9c4,stroke:#f9a825,color:#e65100
+    style BS fill:#ffe0b2,stroke:#e65100,color:#bf360c
+    style FULL fill:#ffcdd2,stroke:#c62828,color:#b71c1c
+```
+
+When not called by the orchestrator (standalone usage), defaults to broad-scan mode.
+
 ### 1. init — Initialize
 
 Called on first use in a project. Scans project file structure, generates initial snapshot.

package/skills-en/task-difficulty/SKILL.md

@@ -16,6 +16,7 @@ This Skill serves as a **throttle valve**: assess difficulty before execution, p
 ```mermaid
 graph LR
     INPUT["User Input<br/>Task Description"]
+    CLASS["Input Classification Hint<br/>Pinpoint/Bounded/<br>Complex/Grand"]
     CTX["Context Tracing<br/>Files / Modules / Dependencies involved"]
     SCORE["Multi-dimensional Scoring<br/>5 dimensions x 1-5 points"]
     LEVEL["Difficulty Level<br/>L1-L5"]
@@ -24,15 +25,29 @@ graph LR
     OUT_BUMP["Bump Up One Level"]
     RESULT["Output<br/>Difficulty Report"]
 
-    INPUT --> CTX --> SCORE --> LEVEL --> THROTTLE
+    INPUT --> CLASS --> CTX --> SCORE --> LEVEL --> THROTTLE
     THROTTLE -->|"Yes, L1 evidence sufficient"| OUT_KEEP --> RESULT
     THROTTLE -->|"No, uncertainty exists"| OUT_BUMP --> RESULT
 
     style INPUT fill:#e3f2fd,stroke:#1976d2
+    style CLASS fill:#ede7f6,stroke:#4527a0,color:#311b92
     style THROTTLE fill:#fff3e0,stroke:#f57c00,stroke-width:2px
     style RESULT fill:#e8f5e9,stroke:#388e3c
 ```
 
+### Input Classification Hint
+
+When called by the orchestrator, receives the input classification result as a scoring calibration reference (does not replace scoring):
+
+| Input Classification | Expected Score Range | Notes |
+|---------------------|---------------------|-------|
+| Pinpoint | L1-L2 (1-4) | Hint is low-difficulty range, but scoring may exceed (e.g., target involves complex dependency chain) |
+| Bounded | L2-L3 (2-6) | Hint is low-to-mid range |
+| Complex | L3-L4 (4-8) | Hint is mid-to-high range |
+| Grand | L4-L5 (7-10) | Hint is high-difficulty range |
+
+If actual score deviates from the classification hint's expected range by > 2 levels, the deviation reason must be noted in the difficulty report.
+
 ## Difficulty Levels
 
 | Level | Name | Typical Characteristics | Example |

package/.claude-plugin/plugin.json

@@ -1,17 +0,0 @@
-{
-  "name": "ironweave",
-  "description": "Agentic skills framework for software development: orchestration, requirements, architecture, TDD, and quality gates",
-  "version": "1.0.0",
-  "homepage": "https://github.com/YuluoY/ironware",
-  "repository": "https://github.com/YuluoY/ironware",
-  "license": "MIT",
-  "keywords": [
-    "skills",
-    "orchestrator",
-    "tdd",
-    "architecture",
-    "quality-gates",
-    "workflows"
-  ],
-  "hooks": "./hooks/hooks.json"
-}

package/.codex/INSTALL.md

@@ -1,45 +0,0 @@
-# Installing Ironweave for Codex
-
-## Installation
-
-1. **Clone the repository:**
-   ```bash
-   git clone https://github.com/YuluoY/ironware.git ~/.codex/ironweave
-   ```
-
-2. **Create the skills symlink:**
-   ```bash
-   mkdir -p ~/.agents/skills
-   ln -s ~/.codex/ironweave/skills ~/.agents/skills/ironweave
-   ```
-
-   **Windows (PowerShell):**
-   ```powershell
-   New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.agents\skills"
-   cmd /c mklink /J "$env:USERPROFILE\.agents\skills\ironweave" "$env:USERPROFILE\.codex\ironweave\skills"
-   ```
-
-3. **Restart Codex** to discover the skills.
-
-## Verify
-
-```bash
-ls -la ~/.agents/skills/ironweave
-```
-
-You should see a symlink pointing to the Ironweave skills directory.
-
-## Updating
-
-```bash
-cd ~/.codex/ironweave && git pull
-```
-
-Skills update instantly through the symlink.
-
-## Uninstalling
-
-```bash
-rm ~/.agents/skills/ironweave
-rm -rf ~/.codex/ironweave
-```

package/.cursor-plugin/plugin.json

@@ -1,19 +0,0 @@
-{
-  "name": "ironweave",
-  "displayName": "Ironweave",
-  "description": "Agentic skills framework for software development: orchestration, requirements, architecture, TDD, and quality gates",
-  "version": "1.0.0",
-  "homepage": "https://github.com/YuluoY/ironware",
-  "repository": "https://github.com/YuluoY/ironware",
-  "license": "MIT",
-  "keywords": [
-    "skills",
-    "orchestrator",
-    "tdd",
-    "architecture",
-    "quality-gates",
-    "workflows"
-  ],
-  "skills": "./skills/",
-  "hooks": "./hooks/hooks-cursor.json"
-}

package/.opencode/INSTALL.md

@@ -1,42 +0,0 @@
-# Installing Ironweave for OpenCode
-
-## Prerequisites
-
-- [OpenCode.ai](https://opencode.ai) installed
-
-## Installation
-
-Add ironweave to the `plugin` array in your `opencode.json` (global or project-level):
-
-```json
-{
-  "plugin": ["ironweave@git+https://github.com/YuluoY/ironware.git"]
-}
-```
-
-Restart OpenCode. The plugin auto-installs and registers all skills.
-
-## Usage
-
-Use OpenCode's native `skill` tool:
-
-```
-use skill tool to list skills
-use skill tool to load ironweave/orchestrator
-```
-
-## Updating
-
-Ironweave updates automatically when you restart OpenCode.
-
-To pin a specific version:
-
-```json
-{
-  "plugin": ["ironweave@git+https://github.com/YuluoY/ironware.git#v1.0.0"]
-}
-```
-
-## Uninstalling
-
-Remove the plugin entry from your `opencode.json` and restart OpenCode.

package/gemini-extension.json

@@ -1,6 +0,0 @@
-{
-  "name": "ironweave",
-  "description": "Agentic skills framework for software development: orchestration, requirements, architecture, TDD, and quality gates",
-  "version": "1.0.0",
-  "contextFileName": "GEMINI.md"
-}