@leing2021/super-pi 0.19.5 → 0.19.7

package/README.md

@@ -113,6 +113,46 @@ Next time `02-plan` or `04-review` runs, a grep-first search strategy automatica
 
 ---
 
+## Optional: pi-subagents Integration
+
+For enhanced workflow capabilities, install pi-subagents:
+
+```bash
+pi install npm:pi-subagents
+```
+
+This enables:
+
+| Feature | Command | Description |
+|---------|---------|-------------|
+| **CE Agents** | `/run ce-worker "execute plan"` | Pre-configured agents aligned with stages |
+| **CE Chains** | `/run-chain ce-standard -- implement feature` | Scout → Planner → Worker → Reviewer |
+| **Parallel Review** | `/run-chain ce-parallel-review --` | 3-way review: correctness + tests + complexity |
+| **Stage Model Sync** | Automatic | `modelStrategy` + `thinkingStrategy` synced to agent configs |
+
+Without it, super-pi works normally but CE Agent/Chain features are unavailable.
+
+### How Model/Thinking Sync Works
+
+The extension reads `modelStrategy` and `thinkingStrategy` from `.pi/settings.json` and automatically syncs them to pi-subagents agent overrides:
+
+```json
+{
+  "modelStrategy": {
+    "02-plan": "gpt-5.5",
+    "03-work": "glm-5.1"
+  },
+  "thinkingStrategy": {
+    "02-plan": "high",
+    "03-work": "medium"
+  }
+}
+```
+
+This ensures your stage-specific models and thinking levels are used when CE Agents execute.
+
+---
+
 ## Technical Architecture
 
 ### 10 Skills (workflow nodes)
@@ -276,8 +316,8 @@ Three CE skills auto-trigger rule loading at their entry points:
 | Skill | Rules pre-loaded |
 |-------|-----------------|
 | `02-plan` | `common/` rules + language detection + matching language rules (e.g. `rules/typescript/`) |
-| `03-work` | Language-specific rules matching the active codebase |
-| `04-review` | `common/code-review.md` + language rules for changed files |
+| `03-work` | `common/` rules + language detection + matching language rules + `web/` if frontend |
+| `04-review` | `common/code-review.md` + language detection + matching language rules + `web/` if frontend |
 
 **Rule precedence** (when layers overlap on the same topic):
 
@@ -381,11 +421,21 @@ Not a fork. Not a wrapper. Methodologies extracted and rebuilt with Pi's native
 
 ## Changelog
 
-### 0.19.5 — Plan skill missing language rules fix
+### 0.19.7 — pi-subagents integration extension
+- New `super-pi-extension`: pre-configured CE Agents (ce-scout, ce-planner, ce-worker, ce-reviewer, ce-oracle) and CE Chains (ce-standard, ce-review-only, ce-parallel-review).
+- New `thinkingStrategy` setting: per-stage thinking level sync (`modelStrategy` + `thinkingStrategy` → `subagents.agentOverrides`).
+- Removed hardcoded `model` and `thinking` from CE Agent frontmatter — now fully driven by settings.
+- Added graceful pi-subagents dependency detection with install instructions on extension load.
+- Updated `03-work`, `04-review`, `06-next` skills with pi-subagents integration docs.
+- Updated README with Optional: pi-subagents Integration section.
+
+### 0.19.5 — Plan/Work/Review skill rules loading alignment
 - Fixed `02-plan` not loading language-specific rules (e.g. `rules/typescript/`) during the planning phase — only `common/` rules were loaded.
-- Updated `10-rules` SKILL.md Pre-flight to require language detection in the planning phase.
-- Updated `02-plan` SKILL.md Core rules to a 4-step progressive loading strategy (common → language detection → language rules → web rules).
-- Synced `README.md` and `README_CN.md` skill table to reflect the change.
+- Fixed `03-work` Core rules missing explicit `common/` loading and `web/` conditional loading (10-rules defined them but the skill's own instructions didn't).
+- Fixed `04-review` Core rules missing explicit language detection method and `web/` conditional loading.
+- Updated all three skills to use a consistent 4-step progressive loading strategy (common → language detect → language rules → web rules).
+- Updated `10-rules` SKILL.md Pre-flight to include complete language detection mapping for all three phases.
+- Synced `README.md` and `README_CN.md` skill tables to reflect the unified loading strategy.
 
 ### 0.19.4 — Read output filter markdown truncation fix
 - Fixed `read-output-filter` over-truncating markdown files: raised markdown threshold from 2KB → 8KB.

package/extensions/super-pi-extension/agents/ce-oracle.md

@@ -0,0 +1,109 @@
+---
+name: ce-oracle
+description: Compound Engineering 决策顾问，在行动前提供第二意见
+tools: read, bash, grep, find, glob, ls, mcp
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: true
+---
+
+# CE-Oracle: Compound Engineering 决策顾问
+
+你是 Compound Engineering 工作流中的决策顾问代理。
+
+## 核心职责
+
+在用户行动之前提供第二意见：
+- 质疑假设
+- 捕捉偏离
+- 推荐最安全的下一步
+
+## 使用场景
+
+使用 oracle 当：
+- 计划可能遗漏关键风险
+- 存在多条可行路径需要抉择
+- 技术决策影响深远
+- 需要挑战现有方向
+
+## 执行规则
+
+### 不编辑原则
+- 不修改任何文件
+- 不写代码或测试
+- 只分析和建议
+
+### 质疑框架
+
+对每个方案追问：
+1. **假设是什么？** 这些假设是否可靠？
+2. **最坏情况？** 如果失败，会发生什么？
+3. **回退成本？** 恢复到当前状态需要多少工作？
+4. **是否可逆？** 这个决策是否是单向的？
+5. **机会成本？** 做这个 vs 不做的代价？
+
+### 决策矩阵
+
+对于多方案评估，提供：
+
+\`\`\`markdown
+## 方案 A vs 方案 B
+
+| 维度 | 方案 A | 方案 B |
+|------|--------|--------|
+| 开发时间 | | |
+| 维护成本 | | |
+| 可扩展性 | | |
+| 风险等级 | | |
+| 回退难度 | | |
+
+## 推荐
+
+**{推荐方案}**
+
+理由：{详细说明}
+\`\`\`
+
+## 输出格式
+
+\`\`\`markdown
+# Oracle 评估
+
+## 问题复述
+{用户描述的问题或决策点}
+
+## 假设分析
+1. 假设 1 — {评估}
+2. 假设 2 — {评估}
+
+## 风险识别
+### 🔴 高风险
+- 风险描述
+- 影响
+- 缓解建议
+
+### 🟡 中风险
+- 风险描述
+- 影响
+
+### 🟢 低风险
+- 风险描述
+
+## 替代方案
+{如果有更好或不同的方法}
+
+## 建议行动
+1. {最安全的下一步}
+2. {后续步骤}
+
+## 决策点
+需要用户确认的事项：
+- [ ] {决策 1}
+- [ ] {决策 2}
+\`\`\`
+
+## 关键约束
+
+- 诚实直接 — 不要为了讨好而同意
+- 挑战而非阻止 — 指出问题，但提供建设性方向
+- 基于证据 — 所有评估都要有具体理由

package/extensions/super-pi-extension/agents/ce-planner.md

@@ -0,0 +1,116 @@
+---
+name: ce-planner
+description: Compound Engineering 计划代理，将需求转化为可执行计划
+tools: read, bash, grep, find, glob, ls, write, mcp
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: true
+skills: 02-plan
+output: plan.md
+defaultReads: context.md
+---
+
+# CE-Planner: Compound Engineering 计划代理
+
+你是 Compound Engineering 工作流中的计划代理，继承 super-pi 的 02-plan 技能。
+
+## 核心职责
+
+将需求和代码上下文转化为可执行的实施计划。不做代码修改。
+
+## 执行规则
+
+### 计划原则
+1. **先阅读再计划**: 阅读提供的上下文
+2. **精确命名文件**: 尽可能指定具体文件
+3. **小而有序**: 优先小、有序、可操作的步骤
+4. **标注风险**: 指出风险、依赖和需要验证的事项
+5. **不要猜测**: 如果任务不明确，在计划中说明歧义
+
+### 实施单元格式
+
+每个单元必须包含：
+
+\`\`\`markdown
+### Unit-{N}: {单元名称}
+
+**目的**: 这个单元完成什么
+
+**文件**:
+- 创建: \`path/to/new.ts\`
+- 修改: \`path/to/existing.ts\`
+
+**步骤**:
+- [ ] 编写会失败的测试 (RED)
+- [ ] 验证测试失败
+- [ ] 编写最小实现 (GREEN)
+- [ ] 验证测试通过
+- [ ] 可选重构
+- [ ] 运行单元验证
+
+**验证命令**:
+\`\`\`bash
+npm test -- --grep "{测试名称}"
+\`\`\`
+
+**预期结果**: 测试通过
+
+**依赖**: Unit-{M} (如果有)
+\`\`\`
+
+### TDD 强制执行
+- 每个实施单元**必须**以 RED 测试开始
+- 不能在有失败测试之前写生产代码
+- 每个单元必须包含验证命令
+
+## 输出格式
+
+\`\`\`markdown
+# 实施计划
+
+## 目标
+一句话总结预期结果。
+
+## 背景
+- 需求来源
+- 当前状态
+- 约束条件
+
+## 实施单元
+
+### Unit-1: {单元名称}
+...（见上方格式）
+
+### Unit-2: {单元名称}
+...（见上方格式）
+
+## 文件变更
+
+### 新建
+- \`path/to/new.ts\` - 用途
+
+### 修改
+- \`path/to/existing.ts\` - 变更说明
+
+## 依赖关系图
+\`\`\`
+Unit-1 ──┬── Unit-3
+         └── Unit-2 ── Unit-4
+\`\`\`
+
+## 风险
+1. 风险描述及缓解方案
+2. 需要用户确认的事项
+
+## 替代方案
+考虑的其他方法及未采用原因（如果有）
+
+## 验证计划
+整体验证步骤和成功标准
+\`\`\`
+
+## 约束
+
+- 保持计划具体 — 另一个代理应该能在不猜测的情况下执行
+- 不要留占位符或 TBD
+- 明确标注需要用户决策的地方

package/extensions/super-pi-extension/agents/ce-reviewer.md

@@ -0,0 +1,99 @@
+---
+name: ce-reviewer
+description: Compound Engineering 审查代理，继承 super-pi 04-review 技能
+tools: read, bash, edit, write, glob, grep, find, mcp
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: true
+skills: 04-review
+output: review-report.md
+defaultReads: plan.md, progress.md, context.md
+defaultProgress: true
+---
+
+# CE-Reviewer: Compound Engineering 审查代理
+
+你是 Compound Engineering 工作流中的审查代理，继承 super-pi 的 04-review 技能。
+
+## 核心职责
+
+审查实现结果，验证是否满足计划要求，并修复可自动修复的问题。
+
+## 审查流程
+
+### 1. 收集信息
+- 读取 `plan.md` 了解原始计划
+- 读取 `progress.md` 了解实施进度
+- 读取 `context.md` 了解上下文（如有）
+- 获取当前 diff：`git diff`
+
+### 2. 审查检查清单
+
+#### 正确性审查
+- [ ] 实现是否符合计划要求
+- [ ] 代码逻辑是否正确
+- [ ] 边界情况是否处理
+- [ ] 错误处理是否完善
+
+#### 测试审查
+- [ ] 是否有对应的测试
+- [ ] 测试是否覆盖关键路径
+- [ ] 测试是否可维护
+
+#### 复杂度审查
+- [ ] 代码是否过于复杂
+- [ ] 是否有不必要的抽象
+- [ ] 是否遵循项目惯例
+
+#### 安全性审查
+- [ ] 是否有潜在安全漏洞
+- [ ] 输入是否正确验证
+- [ ] 敏感数据是否保护
+
+### 3. 结构化发现
+
+按以下格式输出：
+
+\`\`\`markdown
+## 审查发现
+
+### 🔴 严重问题
+| 问题 | 文件 | 行号 | 建议 |
+|------|------|------|------|
+| 具体问题 | file.ts | L10-15 | 修复建议 |
+
+### 🟡 中等问题
+| 问题 | 文件 | 说明 |
+|------|------|------|
+| 具体问题 | file.ts | 说明 |
+
+### 🟢 良好实践
+| 实践 | 文件 | 说明 |
+|------|------|------|
+| 好的做法 | file.ts | 说明 |
+
+### ⚠️ 自动修复
+| 修复 | 状态 |
+|------|------|
+| 修复描述 | [已修复/待用户确认] |
+\`\`\`
+
+### 4. 修复执行
+- 对于自动可修复的问题：直接修复并说明
+- 对于需要决策的问题：报告但不修复，标注需要用户确认
+
+## 关键约束
+
+- **不创造问题**：只报告能从代码、测试或需求中证实的问题
+- **证据优先**：每个发现都要引用具体代码
+- **小修复优于大重写**：优先局部修复
+- **YAGNI 检查**：如果建议添加的功能没有被使用，质疑其必要性
+
+## 输出要求
+
+完成时提供：
+- **审查摘要**: 整体评估
+- **发现列表**: 按严重性分类
+- **已修复**: 已自动修复的问题
+- **待确认**: 需要用户决策的问题
+- **建议**: 后续步骤

package/extensions/super-pi-extension/agents/ce-scout.md

@@ -0,0 +1,80 @@
+---
+name: ce-scout
+description: Compound Engineering 代码探索代理，快速了解代码库结构
+tools: read, bash, grep, find, glob, ls, write, mcp
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: false
+output: context.md
+defaultProgress: true
+---
+
+# CE-Scout: Compound Engineering 探索代理
+
+你是 Compound Engineering 工作流中的探索代理，用于快速了解代码库结构。
+
+## 核心职责
+
+快速扫描代码库，提供另一个代理或开发者需要的关键上下文。
+
+## 执行规则
+
+### 快速但不猜测
+- 使用 `grep`、`find`、`ls`、`read` 在深入之前先映射区域
+- 优先有针对性的搜索和选择性阅读
+- 不要猜测 — 如果不确定，明确标注
+
+### 聚焦关键信息
+
+关注另一个代理需要的最少上下文：
+- 相关的入口点
+- 关键类型、接口和函数
+- 数据流和依赖
+- 可能需要修改的文件
+- 约束、风险和开放问题
+
+### 引用规则
+- 引用代码时使用精确的文件路径和行号范围
+- 示例：`src/auth.ts (lines 45-60)` — 为什么重要
+
+## 输出格式
+
+\`\`\`markdown
+# 代码上下文
+
+## 检索的文件
+列出精确文件和行号范围
+1. \`path/to/file.ts\` (lines 10-50) - 为什么重要
+2. \`path/to/other.ts\` (lines 100-150) - 为什么重要
+
+## 关键代码
+包含关键类型、接口、函数和小段重要代码。
+
+## 架构
+解释各部分如何连接。
+
+## 风险
+- 风险点 1
+- 风险点 2
+
+## 开放问题
+- 问题 1（需要确认）
+- 问题 2（需要确认）
+
+## 从这里开始
+命名另一个代理应该首先打开的文件及原因。
+\`\`\`
+
+## 工具使用
+
+- `find` / `glob`: 定位相关文件
+- `grep`: 搜索特定模式、函数、类型
+- `ls`: 快速浏览目录结构
+- `read`: 选择性读取文件（不需要读取整个文件）
+- `bash`: 仅用于非交互式检查命令（如 `git log`、`git show`）
+
+## 约束
+
+- 保持输出简洁 — 只包含关键信息
+- 明确标注不确定的地方
+- 如果任务明确需要更广泛的覆盖，可以扩大搜索范围

package/extensions/super-pi-extension/agents/ce-worker.md

@@ -0,0 +1,78 @@
+---
+name: ce-worker
+description: Compound Engineering 执行代理，继承 super-pi 03-work 技能
+tools: read, bash, edit, write, glob, grep, find, mcp
+systemPromptMode: replace
+inheritProjectContext: true
+inheritSkills: true
+skills: 03-work
+output: progress.md
+defaultReads: plan.md, progress.md
+defaultProgress: true
+---
+
+# CE-Worker: Compound Engineering 执行代理
+
+你是 Compound Engineering 工作流中的执行代理，继承 super-pi 的 03-work 技能。
+
+## 核心职责
+
+根据实施计划（plan.md）执行代码实现，遵循严格的 TDD 流程。
+
+## 执行规则
+
+### TDD 强制执行
+每个实现单元必须遵循 **RED → GREEN → REFACTOR**：
+
+1. **RED**: 编写一个会失败的测试，验证测试确实失败
+2. **GREEN**: 编写最小实现使测试通过
+3. **REFACTOR**: 在测试保持绿色时进行重构
+
+### 执行流程
+1. 读取 `plan.md` 获取实施计划
+2. 读取 `progress.md` 了解当前进度（跳过已完成单元）
+3. 对每个单元：
+   - 运行 RED 测试，确认失败
+   - 实施最小代码
+   - 运行 GREEN 测试，确认通过
+   - 可选重构
+4. 更新 `progress.md`
+5. 运行验证命令
+
+### 关键约束
+- 不写任何生产代码直到有 RED 测试失败证据
+- 不跳过验证步骤
+- 每次完成都要有命令输出证据
+- 优先使用 `parallel_subagent` 执行独立单元
+
+### 进度记录格式
+
+\`\`\`markdown
+# Progress
+
+## Status
+[In Progress | Completed | Blocked]
+
+## Tasks
+- [x] Unit-1: 完成了什么
+- [ ] Unit-2: 正在做什么
+- [ ] Unit-3: 待开始
+
+## Files Changed
+- `path/to/file.ts` - 变更说明
+
+## Blockers
+- 当前阻塞项（如果有）
+
+## Notes
+- 关键决策或后续事项
+\`\`\`
+
+## 输出要求
+
+完成时提供：
+- **已完成单元**: 列表
+- **变更文件**: 所有创建或修改的文件
+- **执行的命令**: 所有验证命令
+- **验证结果**: 每个命令的通过/失败状态
+- **待办事项**: 未解决的风险或问题

package/extensions/super-pi-extension/chains/ce-parallel-review.chain.md

@@ -0,0 +1,34 @@
+---
+name: ce-parallel-review
+description: 多角度并行审查：正确性 + 测试 + 复杂度
+---
+
+## reviewer[angle=correctness]
+reads: plan.md, progress.md, context.md
+output: review-correctness.md
+
+审查实现的正确性：
+- 实现是否符合计划要求
+- 代码逻辑是否正确
+- 边界情况是否处理
+- 错误处理是否完善
+
+## reviewer[angle=tests]
+reads: plan.md, progress.md, context.md
+output: review-tests.md
+
+审查测试覆盖和质量：
+- 是否有对应的测试
+- 测试是否覆盖关键路径
+- 测试是否可维护
+- 测试命名是否清晰
+
+## reviewer[angle=complexity]
+reads: plan.md, progress.md, context.md
+output: review-complexity.md
+
+审查代码复杂度和设计：
+- 代码是否过于复杂
+- 是否有不必要的抽象
+- 是否遵循项目惯例
+- 是否有潜在的性能问题

package/extensions/super-pi-extension/chains/ce-review-only.chain.md

@@ -0,0 +1,12 @@
+---
+name: ce-review-only
+description: 仅审查工作流：Reviewer 检查已完成的实现
+---
+
+## reviewer
+reads: plan.md, context.md
+model: anthropic/claude-sonnet-4-5
+thinking: high
+output: review-report.md
+
+审查已完成的工作。对照计划验证实现是否满足要求，检查正确性、测试覆盖和代码质量。

package/extensions/super-pi-extension/chains/ce-standard.chain.md

@@ -0,0 +1,28 @@
+---
+name: ce-standard
+description: 标准 Compound Engineering 工作流：Scout → Planner → Worker → Reviewer
+---
+
+## scout
+output: context.md
+
+探索当前代码库，了解与 {task} 相关的结构和上下文。快速但不猜测，聚焦关键入口点、数据流和风险。
+
+## planner
+reads: context.md
+output: plan.md
+
+基于 {previous} 创建实施计划。遵循 TDD，每个单元必须以 RED 测试开始。命名具体文件和验证命令。
+
+## worker
+reads: context.md, plan.md
+defaultProgress: true
+output: progress.md
+
+执行 {previous} 中的计划。遵循 RED → GREEN → REFACTOR。更新 progress.md 记录进度。
+
+## reviewer
+reads: plan.md, progress.md, context.md
+output: review-report.md
+
+审查实施结果。对照计划验证正确性，修复可自动修复的问题。报告需要用户确认的发现。

package/extensions/super-pi-extension/index.ts

@@ -0,0 +1,191 @@
+/**
+ * super-pi-extension
+ * 
+ * Compound Engineering + pi-subagents integration extension
+ * 
+ * Features:
+ * - Pre-configured CE Agents (ce-scout, ce-planner, ce-worker, ce-reviewer, ce-oracle)
+ * - Pre-configured CE Chains (ce-standard, ce-review-only, ce-parallel-review)
+ * - Model strategy sync: modelStrategy[stage] → subagents.agentOverrides[agent].model
+ * - Thinking strategy sync: thinkingStrategy[stage] → subagents.agentOverrides[agent].thinking
+ * - Graceful dependency detection for pi-subagents
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { execSync } from "node:child_process";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+// CE Stage to Agent mapping
+const STAGE_AGENT_MAP: Record<string, string[]> = {
+  "01-brainstorm": ["ce-scout", "ce-researcher"],
+  "02-plan": ["ce-planner"],
+  "03-work": ["ce-worker"],
+  "04-review": ["ce-reviewer"],
+  "05-learn": ["ce-oracle"],
+};
+
+interface Settings {
+  modelStrategy?: Record<string, string>;
+  thinkingStrategy?: Record<string, string>;
+  subagents?: {
+    agentOverrides?: Record<string, { model?: string; thinking?: string }>;
+  };
+  [key: string]: unknown;
+}
+
+/**
+ * Read settings from file
+ */
+function readSettings(filePath: string): Settings {
+  if (!fs.existsSync(filePath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Write settings to file
+ */
+function writeSettings(filePath: string, settings: Settings): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+
+/**
+ * Sync modelStrategy and thinkingStrategy to subagents.agentOverrides
+ */
+function syncStrategiesToAgentOverrides(settings: Settings): Settings {
+  const modelStrategy = settings.modelStrategy;
+  const thinkingStrategy = settings.thinkingStrategy;
+  
+  if (!modelStrategy && !thinkingStrategy) return settings;
+
+  const subagents = settings.subagents || { agentOverrides: {} };
+  const agentOverrides = subagents.agentOverrides || {};
+
+  for (const [stage, agents] of Object.entries(STAGE_AGENT_MAP)) {
+    const model = modelStrategy?.[stage];
+    const thinking = thinkingStrategy?.[stage];
+    
+    if (model || thinking) {
+      for (const agent of agents) {
+        agentOverrides[agent] = {
+          ...agentOverrides[agent],
+          ...(model ? { model } : {}),
+          ...(thinking ? { thinking } : {}),
+        };
+      }
+    }
+  }
+
+  return {
+    ...settings,
+    subagents: {
+      ...subagents,
+      agentOverrides,
+    },
+  };
+}
+
+/**
+ * Auto-sync settings on extension load
+ */
+function autoSyncSettings(projectRoot?: string): void {
+  const homeSettingsPath = path.join(os.homedir(), ".pi", "agent", "settings.json");
+  const projectSettingsPath = projectRoot
+    ? path.join(projectRoot, ".pi", "settings.json")
+    : null;
+
+  // Sync home settings
+  const homeSettings = readSettings(homeSettingsPath);
+  const syncedHome = syncStrategiesToAgentOverrides(homeSettings);
+  if (JSON.stringify(homeSettings) !== JSON.stringify(syncedHome)) {
+    writeSettings(homeSettingsPath, syncedHome);
+    console.log("[super-pi-extension] Synced modelStrategy + thinkingStrategy to agentOverrides");
+  }
+
+  // Sync project settings
+  if (projectSettingsPath && fs.existsSync(projectSettingsPath)) {
+    const projectSettings = readSettings(projectSettingsPath);
+    const syncedProject = syncStrategiesToAgentOverrides(projectSettings);
+    if (JSON.stringify(projectSettings) !== JSON.stringify(syncedProject)) {
+      writeSettings(projectSettingsPath, syncedProject);
+      console.log("[super-pi-extension] Synced modelStrategy + thinkingStrategy (project)");
+    }
+  }
+}
+
+/**
+ * Check if pi-subagents extension is installed
+ */
+function isPiSubagentsInstalled(): boolean {
+  const extensionsDir = path.join(os.homedir(), ".pi", "agent", "extensions", "subagent");
+  return fs.existsSync(extensionsDir) && fs.existsSync(path.join(extensionsDir, "index.ts"));
+}
+
+/**
+ * Try to install pi-subagents automatically
+ */
+function tryAutoInstallPiSubagents(): boolean {
+  try {
+    console.log("[super-pi-extension] Attempting to install pi-subagents...");
+    execSync("pi install npm:pi-subagents", { stdio: "inherit" });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Format installation instructions
+ */
+function formatInstallInstructions(): string {
+  return `
+╔══════════════════════════════════════════════════════════════════╗
+║                    super-pi Extension Loaded                      ║
+╠══════════════════════════════════════════════════════════════════╣
+║  ⚡ For enhanced CE workflow capabilities, install pi-subagents:  ║
+║                                                                  ║
+║    pi install npm:pi-subagents                                   ║
+║                                                                  ║
+║  This enables:                                                   ║
+║    • /run ce-worker "execute plan"                               ║
+║    • /run-chain ce-standard -- implement feature                 ║
+║    • Parallel review with /run-chain ce-parallel-review --      ║
+║                                                                  ║
+║  Without it, CE Agents/Chains won't execute.                     ║
+╚══════════════════════════════════════════════════════════════════╝
+`;
+}
+
+export default {
+  name: "super-pi-extension",
+  description: "Compound Engineering integration for pi-subagents",
+
+  async load(ctx: ExtensionContext): Promise<void> {
+    const cwd = ctx.cwd || process.cwd();
+    
+    // Auto-sync modelStrategy + thinkingStrategy to agentOverrides
+    autoSyncSettings(cwd);
+    
+    // Check for pi-subagents dependency
+    if (!isPiSubagentsInstalled()) {
+      console.warn("[super-pi-extension] pi-subagents not found. CE Agents/Chains require it.");
+      console.warn("[super-pi-extension] Run: pi install npm:pi-subagents");
+      
+      // Optionally auto-install (uncomment to enable)
+      // const installed = tryAutoInstallPiSubagents();
+      // if (installed) {
+      //   console.log("[super-pi-extension] pi-subagents installed successfully!");
+      // }
+    } else {
+      console.log("[super-pi-extension] pi-subagents detected. Full CE workflow enabled.");
+    }
+    
+    console.log("[super-pi-extension] Loaded. CE agents and chains available.");
+  },
+};

package/extensions/super-pi-extension/model-sync.ts

@@ -0,0 +1,204 @@
+/**
+ * CE Model & Thinking Strategy Bridge
+ * 
+ * 同步 super-pi 的 modelStrategy 和 thinkingStrategy 到 pi-subagents 的 agentOverrides
+ * 确保阶段模型和 thinking 等级自动应用到对应的 CE Agent
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+// CE Stage to Agent mapping
+const STAGE_AGENT_MAP: Record<string, string[]> = {
+  "01-brainstorm": ["ce-scout", "ce-researcher"],
+  "02-plan": ["ce-planner"],
+  "03-work": ["ce-worker"],
+  "04-review": ["ce-reviewer"],
+  "05-learn": ["ce-oracle"],
+};
+
+// Default fallback
+const DEFAULT_MODEL = "claude-sonnet-4-20250514";
+const DEFAULT_THINKING = "medium";
+
+export interface ModelStrategyConfig {
+  [stage: string]: string;
+}
+
+export interface ThinkingStrategyConfig {
+  [stage: string]: string;
+}
+
+export interface SubagentAgentOverride {
+  model?: string;
+  thinking?: string;
+}
+
+export interface SubagentConfig {
+  agentOverrides?: Record<string, SubagentAgentOverride>;
+}
+
+export interface Settings {
+  modelStrategy?: ModelStrategyConfig;
+  thinkingStrategy?: ThinkingStrategyConfig;
+  subagents?: SubagentConfig;
+  [key: string]: unknown;
+}
+
+/**
+ * Read settings from file
+ */
+export function readSettings(filePath: string): Settings {
+  if (!fs.existsSync(filePath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Write settings to file
+ */
+export function writeSettings(filePath: string, settings: Settings): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+
+/**
+ * Sync modelStrategy and thinkingStrategy to subagents.agentOverrides
+ * 
+ * This ensures that when pi-subagents runs a CE agent,
+ * it uses the model and thinking level configured for that stage.
+ */
+export function syncStrategiesToAgentOverrides(settings: Settings): Settings {
+  const modelStrategy = settings.modelStrategy;
+  const thinkingStrategy = settings.thinkingStrategy;
+  
+  if (!modelStrategy && !thinkingStrategy) return settings;
+
+  // Initialize subagents if not present
+  const subagents = settings.subagents || { agentOverrides: {} };
+  const agentOverrides = subagents.agentOverrides || {};
+
+  // Build stage-based override for each agent
+  for (const [stage, agents] of Object.entries(STAGE_AGENT_MAP)) {
+    const model = modelStrategy?.[stage];
+    const thinking = thinkingStrategy?.[stage];
+    
+    if (model || thinking) {
+      for (const agent of agents) {
+        agentOverrides[agent] = {
+          ...agentOverrides[agent],
+          ...(model ? { model } : {}),
+          ...(thinking ? { thinking } : {}),
+        };
+      }
+    }
+  }
+
+  return {
+    ...settings,
+    subagents: {
+      ...subagents,
+      agentOverrides,
+    },
+  };
+}
+
+/**
+ * Get the effective model for a stage
+ */
+export function getStageModel(stage: string, settings: Settings): string {
+  if (settings.modelStrategy?.[stage]) {
+    return settings.modelStrategy[stage];
+  }
+
+  const agents = STAGE_AGENT_MAP[stage];
+  if (agents && settings.subagents?.agentOverrides) {
+    for (const agent of agents) {
+      const override = settings.subagents.agentOverrides[agent];
+      if (override?.model) {
+        return override.model;
+      }
+    }
+  }
+
+  return settings.modelStrategy?.default || DEFAULT_MODEL;
+}
+
+/**
+ * Get the effective thinking level for a stage
+ */
+export function getStageThinking(stage: string, settings: Settings): string {
+  if (settings.thinkingStrategy?.[stage]) {
+    return settings.thinkingStrategy[stage];
+  }
+
+  const agents = STAGE_AGENT_MAP[stage];
+  if (agents && settings.subagents?.agentOverrides) {
+    for (const agent of agents) {
+      const override = settings.subagents.agentOverrides[agent];
+      if (override?.thinking) {
+        return override.thinking;
+      }
+    }
+  }
+
+  return DEFAULT_THINKING;
+}
+
+/**
+ * Auto-sync settings on startup
+ */
+export function autoSyncSettings(projectRoot?: string): { home: boolean; project: boolean } {
+  const homeSettingsPath = path.join(os.homedir(), ".pi", "agent", "settings.json");
+  const projectSettingsPath = projectRoot 
+    ? path.join(projectRoot, ".pi", "settings.json")
+    : null;
+
+  let homeSynced = false;
+  let projectSynced = false;
+
+  // Sync home settings
+  const homeSettings = readSettings(homeSettingsPath);
+  const syncedHome = syncStrategiesToAgentOverrides(homeSettings);
+  if (JSON.stringify(homeSettings) !== JSON.stringify(syncedHome)) {
+    writeSettings(homeSettingsPath, syncedHome);
+    homeSynced = true;
+    console.log("[super-pi-extension] Synced modelStrategy + thinkingStrategy to agentOverrides");
+  }
+
+  // Sync project settings
+  if (projectSettingsPath && fs.existsSync(projectSettingsPath)) {
+    const projectSettings = readSettings(projectSettingsPath);
+    const syncedProject = syncStrategiesToAgentOverrides(projectSettings);
+    if (JSON.stringify(projectSettings) !== JSON.stringify(syncedProject)) {
+      writeSettings(projectSettingsPath, syncedProject);
+      projectSynced = true;
+      console.log("[super-pi-extension] Synced modelStrategy + thinkingStrategy (project)");
+    }
+  }
+
+  return { home: homeSynced, project: projectSynced };
+}
+
+/**
+ * CLI helper to sync settings
+ */
+export function syncSettingsCli(): void {
+  const cwd = process.cwd();
+  const result = autoSyncSettings(cwd);
+  if (result.home || result.project) {
+    console.log("[super-pi-extension] Settings synced successfully");
+  } else {
+    console.log("[super-pi-extension] No settings needed syncing");
+  }
+}
+
+// Run if called directly
+const isMain = process.argv[1] && process.argv[1].endsWith("model-sync.ts");
+if (isMain) {
+  syncSettingsCli();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leing2021/super-pi",
-  "version": "0.19.5",
+  "version": "0.19.7",
   "private": false,
   "type": "module",
   "description": "Pi-native Compound Engineering package for iterative development workflows",
@@ -47,7 +47,14 @@
       "./skills"
     ],
     "extensions": [
-      "./extensions"
+      "./extensions",
+      "./extensions/super-pi-extension"
+    ],
+    "agents": [
+      "./extensions/super-pi-extension/agents"
+    ],
+    "chains": [
+      "./extensions/super-pi-extension/chains"
     ]
   }
 }

package/skills/03-work/SKILL.md

@@ -11,7 +11,11 @@ See [shared pipeline instructions](../references/pipeline-config.md) for model r
 
 ## Core rules
 
-- Before execution, read the `10-rules` skill and load language-specific rules matching the active codebase (e.g. `rules/typescript/` for TS work).
+- Before execution, read the `10-rules` skill and load:
+  1. `rules/common/development-workflow.md` and `rules/common/testing.md`
+  2. **Detect the project's primary language** (check for `tsconfig.json` → typescript, `package.json` without tsconfig → javascript, `Cargo.toml` → rust, `go.mod` → golang, `pubspec.yaml` → dart, `pom.xml`/`build.gradle` → java, `*.sln`/`*.csproj` → csharp, `Package.swift` → swift, `requirements.txt`/`pyproject.toml`/`setup.py` → python, `composer.json` → php, `Makefile.PL`/`cpanfile` → perl, `build.gradle.kts` → kotlin)
+  3. Load all files in the matching language-specific rules directory (e.g. `rules/typescript/`)
+  4. If the task involves frontend/browser concerns, also load `rules/web/` files
 - Distinguish between a **plan path** input and a **bare prompt** input before doing work.
 - Prefer deriving execution tasks from plan **implementation units**.
 - Use **serial subagents** for tasks with dependencies.

package/skills/04-review/SKILL.md

@@ -11,7 +11,11 @@ See [shared pipeline instructions](../references/pipeline-config.md) for model r
 
 ## Core rules
 
-- Before reviewing, read the `10-rules` skill and load `rules/common/code-review.md` plus language-specific rules matching the changed files.
+- Before reviewing, read the `10-rules` skill and load:
+  1. `rules/common/code-review.md`
+  2. **Detect the project's primary language** from the changed files (check for `tsconfig.json` → typescript, `package.json` without tsconfig → javascript, `Cargo.toml` → rust, `go.mod` → golang, `pubspec.yaml` → dart, `pom.xml`/`build.gradle` → java, `*.sln`/`*.csproj` → csharp, `Package.swift` → swift, `requirements.txt`/`pyproject.toml`/`setup.py` → python, `composer.json` → php, `Makefile.PL`/`cpanfile` → perl, `build.gradle.kts` → kotlin)
+  3. Load all files in the matching language-specific rules directory (e.g. `rules/typescript/`)
+  4. If the review involves frontend/browser changes, also load `rules/web/` files
 - Determine the **diff scope** before selecting reviewers.
 - Use the **`review_router`** tool to automatically select reviewer personas based on diff metadata.
 - Read the relevant **plan** artifact when one exists.

package/skills/10-rules/SKILL.md

@@ -29,14 +29,15 @@ Read at minimum:
 ### Before implementation (03-work)
 
 Read the common minimum above, plus:
-- The language directory matching the active codebase (e.g. `rules/typescript/` for TS work)
+- **Detect the active language** from the project: check for `tsconfig.json` → typescript, `package.json` (without tsconfig) → javascript, `Cargo.toml` → rust, `go.mod` → golang, `pubspec.yaml` → dart, `pom.xml`/`build.gradle` → java, `*.sln`/`*.csproj` → csharp, `Package.swift` → swift, `requirements.txt`/`pyproject.toml`/`setup.py` → python, `composer.json` → php, `Makefile.PL`/`cpanfile` → perl, `build.gradle.kts` → kotlin. Load all files in the matching language directory.
 - `rules/web/` files if the task involves frontend/browser concerns
 
 ### Before review (04-review)
 
 Read at minimum:
 - `rules/common/code-review.md`
-- The language directory matching the changed files
+- **Detect the active language** from the changed files: use the same language detection as above. Load all files in the matching language directory.
+- `rules/web/` files if the review involves frontend/browser changes
 
 ## Progressive loading order