@yan-geroge/omg 0.1.0

package/hooks/lib/keyword-detector.js

@@ -0,0 +1,89 @@
+/**
+ * 关键词检测器 — 纯函数模块
+ *
+ * 从用户 prompt 中检测预设关键词，返回匹配结果。
+ * 此模块为纯函数，不依赖任何外部状态或 I/O，便于单元测试。
+ *
+ * 关键词映射表（按检测顺序排列）：
+ * ┌───────────────┬───────────────┬──────────┐
+ * │ 关键词          │ 技能           │ 优先级    │
+ * ├───────────────┼───────────────┼──────────┤
+ * │ autopilot      │ costrict-autopilot │ 10       │
+ * │ auto（非精确匹配）│ costrict-autopilot │ 5        │
+ * │ team           │ costrict-team      │ 10       │
+ * │ tdd            │ tdd-guide     │ 10       │
+ * └───────────────┴───────────────┴──────────┘
+ *
+ * 匹配规则：
+ * - 匹配不区分大小写
+ * - 优先级相同时取先匹配到的关键词
+ * - "auto" 是部分匹配（包含即命中），其余为词边界匹配
+ */
+
+// 关键词规则配置表
+// 每个规则包含：keyword（检测词）、skill（路由目标技能）、priority（优先级，数字越大越优先）、exact（是否精确词边界匹配）
+const KEYWORD_RULES = [
+  { keyword: 'autopilot', skill: 'oh-my-costrict:costrict-autopilot', priority: 10, exact: true },
+  { keyword: 'auto', skill: 'oh-my-costrict:costrict-autopilot', priority: 5, exact: false },
+  { keyword: 'team', skill: 'oh-my-costrict:costrict-team', priority: 10, exact: true },
+  { keyword: 'tdd', skill: 'oh-my-costrict:tdd-guide', priority: 10, exact: true },
+];
+
+/**
+ * 检测 prompt 中的预设关键词
+ *
+ * @param {string} prompt - 用户输入的文本
+ * @returns {{ keyword: string, skill: string, priority: number } | null}
+ *   匹配成功返回 { keyword, skill, priority }，否则返回 null
+ */
+function detectKeywords(prompt) {
+  // 输入验证：非字符串或空字符串直接返回 null
+  if (typeof prompt !== 'string' || prompt.trim().length === 0) {
+    return null;
+  }
+
+  // 转为小写以支持不区分大小写匹配
+  const lowerPrompt = prompt.toLowerCase();
+
+  // 当前最佳匹配（按优先级比较）
+  let bestMatch = null;
+
+  // 遍历所有规则，寻找最佳匹配
+  for (const rule of KEYWORD_RULES) {
+    const keywordLower = rule.keyword.toLowerCase();
+    let matched = false;
+
+    if (rule.exact) {
+      // 精确匹配：使用词边界正则（\b 为词边界）
+      const exactPattern = new RegExp(`\\b${escapeRegExp(keywordLower)}\\b`);
+      matched = exactPattern.test(lowerPrompt);
+    } else {
+      // 部分匹配：直接检查是否包含
+      matched = lowerPrompt.includes(keywordLower);
+    }
+
+    // 命中且优先级更高的匹配（或首次命中）
+    if (matched && (!bestMatch || rule.priority > bestMatch.priority)) {
+      bestMatch = {
+        keyword: rule.keyword,
+        skill: rule.skill,
+        priority: rule.priority,
+      };
+    }
+  }
+
+  return bestMatch;
+}
+
+/**
+ * 转义正则表达式特殊字符
+ *
+ * @param {string} str - 需要转义的字符串
+ * @returns {string} 转义后的安全字符串
+ */
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// 导出公共 API
+module.exports = { detectKeywords, KEYWORD_RULES };

package/hooks/session-start.mjs

@@ -0,0 +1,104 @@
+/**
+ * SessionStart Hook 脚本
+ *
+ * 在 CSC 会话启动时触发，读取 claude.md 编排大脑文件，
+ * 将其内容作为 systemMessage 注入到 AI 的 system prompt 中。
+ *
+ * 输入 (stdin JSON)：
+ *   { hook_event_name: "SessionStart", session_id: string, cwd: string }
+ *
+ * 输出 (stdout JSON)：
+ *   { continue: true, systemMessage: "<claude.md 内容>" }
+ *
+ * 使用方式：由 CSC hook 引擎以 command 类型调用：
+ *   node "${CLAUDE_PLUGIN_ROOT}/hooks/session-start.mjs"
+ */
+
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+/**
+ * 读取 stdin 的 JSON 输入
+ *
+ * @returns {Promise<object>} 解析后的输入对象
+ */
+async function readStdin() {
+  // 收集 stdin 的所有数据块
+  return new Promise((resolveStdin, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => {
+      try {
+        // 尝试将 stdin 内容解析为 JSON
+        resolveStdin(JSON.parse(data.trim() || '{}'));
+      } catch {
+        // JSON 解析失败时返回空对象，不阻塞 CSC
+        resolveStdin({});
+      }
+    });
+    process.stdin.on('error', (err) => {
+      // stdin 读取失败时返回空对象，保持非侵入式
+      resolveStdin({});
+    });
+    process.stdin.resume();
+  });
+}
+
+/**
+ * 读取 claude.md 编排器文件
+ *
+ * @returns {Promise<string>} 文件内容，读取失败时返回空字符串
+ */
+async function readOrchestrationBrain() {
+  try {
+    // 使用 CLAUDE_PLUGIN_ROOT 环境变量定位插件根目录
+    const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
+    if (!pluginRoot) {
+      // 环境变量未设置，降级为相对路径（当前工作目录）
+      const claudeMdPath = resolve(process.cwd(), 'claude.md');
+      return await readFile(claudeMdPath, 'utf-8');
+    }
+    // 拼接 claude.md 的完整路径
+    const filePath = resolve(pluginRoot, 'claude.md');
+    // 读取文件内容
+    return await readFile(filePath, 'utf-8');
+  } catch {
+    // 文件读取失败不阻塞 CSC，返回空字符串
+    return '';
+  }
+}
+
+/**
+ * 主函数：读取输入 -> 注入编排器 system prompt -> 输出响应
+ */
+async function main() {
+  // 读取 stdin 输入（hook 事件信息）
+  const input = await readStdin();
+
+  // 读取 claude.md 编排大脑文件
+  const orchestrationContent = await readOrchestrationBrain();
+
+  // 构造 hook 响应 JSON
+  const response = {
+    continue: true,
+    systemMessage: orchestrationContent,
+    stopReason: null,
+  };
+
+  // 输出到 stdout（CSC hook 引擎读取）
+  process.stdout.write(JSON.stringify(response));
+}
+
+// 执行主函数
+main().catch(() => {
+  // 任何未预期的错误都不阻塞 CSC，返回空 systemMessage
+  const fallback = {
+    continue: true,
+    systemMessage: '',
+    stopReason: null,
+  };
+  process.stdout.write(JSON.stringify(fallback));
+});

package/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "omc-local",
+  "description": "oh-my-costrict 本地 marketplace 注册 — 用于开发及手动安装",
+  "plugins": [
+    {
+      "name": "oh-my-costrict",
+      "version": "0.1.0",
+      "source": "./",
+      "category": "productivity"
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@yan-geroge/omg",
+  "version": "0.1.0",
+  "description": "CSC 多智能体编排插件 — 为 CSC 提供多智能体编排、技能路由、生命周期 Hook 注入能力",
+  "main": "plugin.json",
+  "files": [
+    "plugin.json",
+    "marketplace.json",
+    "agents/",
+    "skills/",
+    "hooks/",
+    "scripts/",
+    "CLAUDE.md",
+    ".claude/",
+    "!.claude/settings.local.json"
+  ],
+  "scripts": {
+    "prepublishOnly": "node -e \"const fs=require('fs');const p=JSON.parse(fs.readFileSync('plugin.json','utf8'));const pk=JSON.parse(fs.readFileSync('package.json','utf8'));if(p.version!==pk.version){console.error('version mismatch: plugin.json='+p.version+' package.json='+pk.version);process.exit(1);}console.log('✓ plugin.json version matches package.json');\"",
+    "pack:check": "npm pack --dry-run"
+  },
+  "keywords": [
+    "csc",
+    "costrict",
+    "plugin",
+    "multi-agent",
+    "orchestration",
+    "oh-my-costrict"
+  ],
+  "author": "yan-geroge",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "oh-my-costrict",
+  "version": "0.1.0",
+  "description": "CSC 多智能体编排插件 — 为 CSC 提供多智能体编排、技能路由、生命周期 Hook 注入能力",
+  "skills": "./skills/",
+  "hooks": {
+    "SessionStart": [
+      { "hooks": [{ "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/session-start.mjs\"", "timeout": 10000 }] }
+    ],
+    "UserPromptSubmit": [
+      { "hooks": [{ "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/keyword-detector.mjs\"", "timeout": 5000 }] }
+    ]
+  }
+}

package/scripts/diagnose-marketplace.js

@@ -0,0 +1,84 @@
+const fs = require('fs');
+const path = require('path');
+
+// 手动验证 marketplace.json
+const mpPath = 'C:/Users/SXF-Admin/.claude/plugins/cache/local/oh-my-costrict/0.1.0/.claude-plugin/marketplace.json';
+const mp = JSON.parse(fs.readFileSync(mpPath, 'utf-8'));
+
+console.log('=== marketplace.json ===');
+console.log('name:', mp.name);
+console.log('owner:', JSON.stringify(mp.owner));
+console.log('plugins count:', mp.plugins?.length);
+console.log('plugin[0].name:', mp.plugins?.[0]?.name);
+console.log('plugin[0].source:', JSON.stringify(mp.plugins?.[0]?.source));
+console.log('plugin[0].source type:', typeof mp.plugins?.[0]?.source);
+
+// 检查所需字段
+const checks = [
+  ['name is non-empty string', typeof mp.name === 'string' && mp.name.length > 0],
+  ['name has no spaces', !mp.name.includes(' ')],
+  ['owner exists', mp.owner !== undefined && mp.owner !== null],
+  ['owner.name is non-empty', typeof mp.owner?.name === 'string' && mp.owner.name.length > 0],
+  ['plugins is array', Array.isArray(mp.plugins)],
+  ['plugins[0].name exists', typeof mp.plugins?.[0]?.name === 'string'],
+  ['plugins[0].source exists', mp.plugins?.[0]?.source !== undefined],
+  ['plugins[0].source is string starting with ./', typeof mp.plugins?.[0]?.source === 'string' && mp.plugins[0].source.startsWith('./')],
+];
+
+let allPass = true;
+for (const [name, result] of checks) {
+  console.log(result ? '  PASS' : '  FAIL', '-', name);
+  if (!result) allPass = false;
+}
+
+// 检查 known_marketplaces.json
+const kmPath = 'C:/Users/SXF-Admin/.claude/plugins/known_marketplaces.json';
+const km = JSON.parse(fs.readFileSync(kmPath, 'utf-8'));
+
+console.log('\n=== known_marketplaces.json ===');
+console.log('local entry exists:', !!km.local);
+console.log('local.source:', JSON.stringify(km.local?.source));
+console.log('local.installLocation:', km.local?.installLocation);
+
+// 验证 installLocation 指向的 .claude-plugin/marketplace.json
+const nestedPath = path.join(km.local?.installLocation || '', '.claude-plugin', 'marketplace.json');
+console.log('\n=== installLocation check ===');
+console.log('installLocation exists:', fs.existsSync(km.local?.installLocation));
+console.log('.claude-plugin/marketplace.json exists:', fs.existsSync(nestedPath));
+
+// 验证 installLocation 目录下的文件
+if (km.local?.installLocation && fs.existsSync(km.local.installLocation)) {
+  console.log('\ninstallLocation contents:');
+  fs.readdirSync(km.local.installLocation).forEach(f => console.log('  ', f));
+  const cpPath = path.join(km.local.installLocation, '.claude-plugin');
+  if (fs.existsSync(cpPath)) {
+    console.log('\n.claude-plugin contents:');
+    fs.readdirSync(cpPath).forEach(f => console.log('  ', f));
+  }
+}
+
+// 验证 installed_plugins.json
+const ipPath = 'C:/Users/SXF-Admin/.claude/plugins/installed_plugins.json';
+const ip = JSON.parse(fs.readFileSync(ipPath, 'utf-8'));
+console.log('\n=== installed_plugins.json ===');
+const costrictEntry = ip.plugins?.['oh-my-costrict@local'];
+console.log('oh-my-costrict@local entry:', !!costrictEntry);
+if (costrictEntry?.[0]) {
+  console.log('  installPath:', costrictEntry[0].installPath);
+  console.log('  version:', costrictEntry[0].version);
+  console.log('  scope:', costrictEntry[0].scope);
+}
+
+// 尝试用 CSC 的 schema 验证
+console.log('\n=== CSC Schema Validation ===');
+try {
+  // 动态导入 CSC 的 schemas 模块
+  const schemasPath = 'C:/nvm4w/nodejs/node_modules/@costrict/csc/dist/utils/plugins/schemas.js';
+  console.log('Trying schemas at:', schemasPath);
+  console.log('File exists:', fs.existsSync(schemasPath));
+} catch(e) {
+  console.log('Schema import error:', e.message);
+}
+
+console.log('\n=== All manual checks done ===');
+console.log(allPass ? 'ALL MANUAL CHECKS PASSED' : 'SOME MANUAL CHECKS FAILED');

package/scripts/e2e-diagnose.mjs

@@ -0,0 +1,118 @@
+// 端到端模拟 CSC 插件加载流程
+// 1. 验证 known_marketplaces.json → KnownMarketplacesFileSchema
+// 2. 验证 marketplace.json → PluginMarketplaceSchema
+// 3. 模拟 loadPluginsFromMarketplaces 流程
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const fs = require('fs');
+const path = require('path');
+
+const KNOWN_MP_PATH = 'C:/Users/SXF-Admin/.claude/plugins/known_marketplaces.json';
+const INSTALLED_PLUGINS_PATH = 'C:/Users/SXF-Admin/.claude/plugins/installed_plugins.json';
+const CACHE_DIR = 'C:/Users/SXF-Admin/.claude/plugins/cache/local/oh-my-costrict/0.1.0';
+const MP_PATH = path.join(CACHE_DIR, '.claude-plugin', 'marketplace.json');
+const PLUGIN_PATH = path.join(CACHE_DIR, '.claude-plugin', 'plugin.json');
+
+console.log('=== 步骤 1: 读取 known_marketplaces.json ===');
+const km = JSON.parse(fs.readFileSync(KNOWN_MP_PATH, 'utf-8'));
+console.log('local entry exists:', !!km.local);
+console.log('local.source:', JSON.stringify(km.local?.source));
+console.log('local.installLocation:', km.local?.installLocation);
+console.log('local.lastUpdated:', km.local?.lastUpdated);
+
+// 检查 MarketplaceSourceSchema 的关键约束
+const localSource = km.local?.source;
+console.log('\n=== 步骤 2: MarketplaceSourceSchema 检查 ===');
+console.log('source.source type:', localSource?.source);
+console.log('source.source === "directory":', localSource?.source === 'directory');
+console.log('source.path is string:', typeof localSource?.path === 'string');
+console.log('source.path exists:', fs.existsSync(localSource?.path));
+
+console.log('\n=== 步骤 3: 读取 marketplace.json (PluginMarketplaceSchema) ===');
+const mp = JSON.parse(fs.readFileSync(MP_PATH, 'utf-8'));
+console.log('marketplace name:', mp.name);
+console.log('marketplace owner:', JSON.stringify(mp.owner));
+console.log('plugins count:', mp.plugins?.length);
+console.log('plugin[0].name:', mp.plugins?.[0]?.name);
+console.log('plugin[0].source:', mp.plugins?.[0]?.source);
+console.log('plugin[0].source type:', typeof mp.plugins?.[0]?.source);
+console.log('plugin[0].source starts with ./:', mp.plugins?.[0]?.source?.startsWith('./'));
+
+console.log('\n=== 步骤 4: 插件 .claude-plugin 目录检查 ===');
+console.log('.claude-plugin/ exists:', fs.existsSync(path.join(CACHE_DIR, '.claude-plugin')));
+console.log('plugin.json exists:', fs.existsSync(PLUGIN_PATH));
+const pluginJson = JSON.parse(fs.readFileSync(PLUGIN_PATH, 'utf-8'));
+console.log('plugin name:', pluginJson.name);
+console.log('plugin version:', pluginJson.version);
+console.log('plugin skills:', pluginJson.skills);
+console.log('plugin hooks keys:', Object.keys(pluginJson.hooks || {}));
+
+console.log('\n=== 步骤 5: Skills 目录检查 ===');
+const skillsDir = path.join(CACHE_DIR, 'skills');
+if (fs.existsSync(skillsDir)) {
+  const skills = fs.readdirSync(skillsDir, { withFileTypes: true });
+  for (const s of skills) {
+    if (s.isDirectory()) {
+      const skillMd = path.join(skillsDir, s.name, 'SKILL.md');
+      const agentMd = path.join(skillsDir, s.name);
+      console.log(`  ${s.name}/`);
+      console.log(`    SKILL.md exists: ${fs.existsSync(skillMd)}`);
+    }
+  }
+}
+
+console.log('\n=== 步骤 6: Agents 目录检查 ===');
+const agentsDir = path.join(CACHE_DIR, 'agents');
+if (fs.existsSync(agentsDir)) {
+  const agents = fs.readdirSync(agentsDir);
+  console.log(`  ${agents.length} agent files:`, agents.join(', '));
+} else {
+  console.log('  agents/ 目录不存在!');
+}
+
+console.log('\n=== 步骤 7: Hooks 目录检查 ===');
+const hooksDir = path.join(CACHE_DIR, 'hooks');
+if (fs.existsSync(hooksDir)) {
+  const hooks = fs.readdirSync(hooksDir);
+  console.log(`  hooks:`, hooks.join(', '));
+  // 检查 hook 脚本可执行性
+  for (const h of hooks) {
+    const hookPath = path.join(hooksDir, h);
+    const stat = fs.statSync(hookPath);
+    console.log(`  ${h}: ${stat.size} bytes`);
+  }
+} else {
+  console.log('  hooks/ 目录不存在!');
+}
+
+console.log('\n=== 步骤 8: installed_plugins.json 检查 ===');
+const ip = JSON.parse(fs.readFileSync(INSTALLED_PLUGINS_PATH, 'utf-8'));
+const entry = ip.plugins?.['oh-my-costrict@local'];
+console.log('oh-my-costrict@local entry:', !!entry);
+if (entry) {
+  console.log('  installPath:', entry[0]?.installPath);
+  console.log('  version:', entry[0]?.version);
+  console.log('  scope:', entry[0]?.scope);
+  console.log('  installPath exists:', fs.existsSync(entry[0]?.installPath));
+}
+
+console.log('\n=== 步骤 9: 模拟 getPluginByIdCacheOnly 查找 ===');
+// 模拟: 从 marketplace.plugins 搜索插件
+const found = mp.plugins?.find(p => p.name === 'oh-my-costrict');
+console.log('在 marketplace.json 中找到 oh-my-costrict:', !!found);
+if (found) {
+  // 模拟: loadPluginFromMarketplaceEntryCacheOnly
+  const pluginPath_resolved = path.join(CACHE_DIR, found.source);
+  console.log('解析后的 pluginPath:', pluginPath_resolved);
+  console.log('pluginPath 的 .claude-plugin/plugin.json 存在:', fs.existsSync(path.join(pluginPath_resolved, '.claude-plugin', 'plugin.json')));
+}
+
+console.log('\n=== 最终结论 ===');
+const allOk =
+  fs.existsSync(MP_PATH) &&
+  fs.existsSync(PLUGIN_PATH) &&
+  mp.plugins?.find(p => p.name === 'oh-my-costrict') &&
+  fs.existsSync(path.join(CACHE_DIR, '.claude-plugin')) &&
+  km.local?.source?.source === 'directory';
+
+console.log(allOk ? '✅ 所有检查通过 - 插件应该可以加载' : '❌ 存在问题 - 检查上述输出');

package/scripts/validate-with-csc-schema.mjs

@@ -0,0 +1,87 @@
+// 使用 CSC 运行时 schema 验证 marketplace.json
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const mpPath = 'C:/Users/SXF-Admin/.claude/plugins/cache/local/oh-my-costrict/0.1.0/.claude-plugin/marketplace.json';
+const fs = require('fs');
+
+// 方法 1: 尝试从 @costrict/csc 导入 schemas
+async function tryImportCsc() {
+  try {
+    console.log('尝试方法 1: 从 @costrict/csc 导入...');
+    const csc = await import('@costrict/csc');
+    console.log('CSC exports:', Object.keys(csc));
+  } catch (e) {
+    console.log('方法 1 失败:', e.message);
+  }
+}
+
+// 方法 2: 尝试 require csc dist services
+function tryRequireServices() {
+  try {
+    console.log('\n尝试方法 2: require CSC dist...');
+    const schemas = require('C:/nvm4w/nodejs/node_modules/@costrict/csc/dist/cli.js');
+    console.log('Loaded CSC dist, keys:', Object.keys(schemas).slice(0, 20));
+  } catch (e) {
+    console.log('方法 2 失败:', e.message);
+  }
+}
+
+// 方法 3: 读取 bundled CLI 源码，搜索 PluginMarketplaceSchema
+function searchBundledSchema() {
+  console.log('\n尝试方法 3: 搜索 bundled 文件中的 schema...');
+  const cliPath = 'C:/nvm4w/nodejs/node_modules/@costrict/csc/dist/cli.js';
+  const content = fs.readFileSync(cliPath, 'utf-8');
+
+  // 搜索 PluginMarketplaceSchema
+  const match = content.match(/PluginMarketplaceSchema\s*=\s*lazySchema[^}]*\}\s*\)\s*\)/);
+  if (match) {
+    console.log('找到 PluginMarketplaceSchema 定义 (部分):', match[0].substring(0, 200));
+  } else {
+    console.log('未找到完整定义，搜索片段...');
+    const idx = content.indexOf('PluginMarketplaceSchema');
+    if (idx >= 0) {
+      console.log('上下文:', content.substring(idx, idx + 500));
+    }
+  }
+
+  // 搜索 MarketplaceNameSchema
+  const mnIdx = content.indexOf('MarketplaceNameSchema');
+  if (mnIdx >= 0) {
+    console.log('\nMarketplaceNameSchema 上下文:', content.substring(mnIdx, mnIdx + 600));
+  }
+
+  // 搜索 PluginMarketplaceEntrySchema
+  const peIdx = content.indexOf('PluginMarketplaceEntrySchema');
+  if (peIdx >= 0) {
+    console.log('\nPluginMarketplaceEntrySchema 上下文:', content.substring(peIdx, peIdx + 800));
+  }
+}
+
+// 方法 4: 直接测试 JSON 解析和基本格式
+function manualCheck() {
+  console.log('\n=== 手动验证 marketplace.json ===');
+  const mp = JSON.parse(fs.readFileSync(mpPath, 'utf-8'));
+
+  console.log('顶层 keys:', Object.keys(mp));
+  console.log('name type:', typeof mp.name, 'value:', mp.name);
+  console.log('owner type:', typeof mp.owner, 'keys:', Object.keys(mp.owner));
+  console.log('plugins is array:', Array.isArray(mp.plugins));
+  console.log('plugins[0]:', JSON.stringify(mp.plugins[0], null, 2));
+
+  // 检查相对路径
+  const source = mp.plugins[0].source;
+  console.log('\nsource 检查:');
+  console.log('  类型:', typeof source);
+  console.log('  值:', JSON.stringify(source));
+  console.log('  是否以 ./ 开头:', typeof source === 'string' && source.startsWith('./'));
+}
+
+async function main() {
+  manualCheck();
+  await tryImportCsc();
+  tryRequireServices();
+  searchBundledSchema();
+}
+
+main().catch(console.error);

package/skills/costrict-autopilot/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: costrict-autopilot
+description: 自动审查流水线 — 全自动质量门（PRD → 设计审查 → 工程审查 → DX 审查 → 汇总报告）
+argument-hint: "<任务描述>"
+---
+
+# /costrict-autopilot — 自动审查流水线
+
+## 概述
+
+全自动质量门流水线，依次执行以下五个阶段，每个阶段产出一个审查报告，最终汇总为完整的质量评估。
+
+## 执行流程
+
+### Phase 1: PRD 生成
+- 委托 **planner** 代理分析任务需求
+- 产出一份结构化的 PRD 文档，包含：目标、范围、验收标准、技术约束
+- 输出格式：markdown 文档
+
+### Phase 2: 设计审查
+- 委托 **architect** 代理审查 PRD 中的技术方案
+- 检查点：架构合理性、技术选型、扩展性、安全性
+- 输出：设计审查报告（通过/需修改/拒绝 + 具体建议）
+
+### Phase 3: 工程审查
+- 委托 **reviewer** 代理审查代码实现
+- 检查点：代码质量、命名规范、错误处理、性能、安全
+- 输出：工程审查报告（CRITICAL/HIGH/MEDIUM/LOW 分级问题列表）
+
+### Phase 4: DX 审查（开发者体验）
+- 委托 **reviewer** 代理审查开发者体验
+- 检查点：API 易用性、文档完整性、错误信息友好度、配置复杂度
+- 输出：DX 审查报告（改进建议列表）
+
+### Phase 5: 汇总报告
+- 汇总前四个阶段的审查结果
+- 生成最终质量评估报告，包含：
+  - 各阶段通过/失败状态
+  - 问题汇总（按严重程度排序）
+  - 改进建议优先级列表
+  - 整体质量评分（A/B/C/D/F）
+
+## 使用方式
+
+```
+/costrict-autopilot 实现用户登录功能，包含 JWT 认证和密码加密
+```
+
+## 注意事项
+
+- 每个阶段独立执行，前序阶段的输出作为后续阶段的输入
+- 任一步骤失败（审查结果为"拒绝"）则终止后续步骤并报告
+- 所有代理使用 CSC 默认模型，无需手动指定

package/skills/costrict-team/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: costrict-team
+description: 多智能体团队编排 — 将任务拆解分发给多个子代理并行执行，含审查和修复循环
+argument-hint: "<任务描述>"
+---
+
+# /costrict-team — 多智能体团队编排
+
+## 概述
+
+将一个复杂任务拆解为子任务，分发给多个 executor 代理并行执行，经由 reviewer 审查后进入修复循环，最终由 verifier 验证完成。
+
+## 执行流程
+
+### Step 1: 规划
+- 委托 **planner** 代理分析任务
+- 将任务拆解为 2-5 个可并行执行的独立子任务
+- 为每个子任务生成明确的任务描述和验收标准
+- 识别子任务间的依赖关系（如有）
+
+### Step 2: 并行执行
+- 为每个独立子任务启动一个 **executor** 代理
+- 所有 executor 代理**同时并行**工作
+- 每个 executor 独立完成：阅读代码 → 实现修改 → 自我验证
+- 有依赖关系的子任务按拓扑顺序分批执行
+
+### Step 3: 审查
+- 委托 **reviewer** 代理审查所有 executor 的产出
+- 检查点：代码质量、一致性、跨子任务兼容性、安全
+- 输出：审查报告（通过 / 需修改列表）
+
+### Step 4: 修复循环
+- 如果审查发现需修改的问题：
+  - 将问题列表分发给相应的 executor 代理
+  - executor 修复后重新提交
+  - reviewer 重新审查
+- **最多 3 轮**修复循环
+- 超过 3 轮仍未通过，则报告阻塞并请求人工介入
+
+### Step 5: 验证
+- 委托 **verifier** 代理运行测试套件
+- 验证：所有测试通过、覆盖率 >= 80%
+- 输出：验证报告（通过/失败 + 覆盖率数据）
+
+## 使用方式
+
+```
+/costrict-team 重构用户模块：拆分 service 层，添加单元测试，优化数据库查询
+```
+
+## 子任务示例
+
+对于上述命令，planner 会拆解为：
+1. 拆分 service 层（独立）
+2. 添加单元测试（独立，可与1并行）
+3. 优化数据库查询（独立，可与1、2并行）
+
+三个 executor 并行执行，完成后统一审查。
+
+## 注意事项
+
+- 子任务数量控制在 2-5 个，避免过度拆分
+- 有依赖关系的子任务按拓扑顺序串行执行
+- 修复循环最多 3 轮，超过则报告并等待人工决策
+- 所有代理使用 CSC 默认模型