code-abyss 2.0.0 → 2.0.2

package/README.md

@@ -4,7 +4,7 @@
 
 **邪修红尘仙 · 宿命深渊**
 
-*一键为 Claude Code / Codex CLI 注入邪修人格与 56 篇安全工程秘典*
+*一键为 Claude Code / Codex CLI 注入邪修人格与攻防安全工程知识体系*
 
 [![npm](https://img.shields.io/npm/v/code-abyss.svg)](https://www.npmjs.com/package/code-abyss)
 [![CI](https://github.com/telagod/code-abyss/actions/workflows/ci.yml/badge.svg)](https://github.com/telagod/code-abyss/actions/workflows/ci.yml)
@@ -20,12 +20,13 @@
 
 ```bash
 npx code-abyss
+npx code-abyss --list-styles
 ```
 
 交互式菜单（方向键选择，回车确认）：
 
 ```
-☠️ Code Abyss v1.7.3
+☠️ Code Abyss v2.0.2
 
 ? 请选择操作 (Use arrow keys)
 ❯ 安装到 Claude Code (~/.claude/)
@@ -39,8 +40,11 @@ npx code-abyss
 ```bash
 npx code-abyss --target claude    # 安装到 ~/.claude/
 npx code-abyss --target codex     # 安装到 ~/.codex/
+npx code-abyss --style abyss-concise --target claude
+npx code-abyss --style abyss-concise --target codex
 npx code-abyss --target claude -y  # 零配置一键安装 (自动合并推荐配置)
 npx code-abyss --target codex -y   # 零配置一键安装 (自动写入 config.toml 模板)
+npx code-abyss --list-styles       # 列出可用输出风格
 npx code-abyss --uninstall claude  # 卸载 Claude Code
 npx code-abyss --uninstall codex   # 卸载 Codex CLI
 ```
@@ -61,6 +65,8 @@ npx code-abyss --uninstall codex   # 卸载 Codex CLI
 
 未检测到认证时会提示配置，可交互输入或跳过。
 
+安装前可选择输出风格；若显式传入 `--style <slug>`，则跳过风格选择并直接安装指定风格。
+
 然后进入可选配置（空格选择，回车确认）：
 
 ```
@@ -74,6 +80,17 @@ npx code-abyss --uninstall codex   # 卸载 Codex CLI
 
 > 已有配置会自动备份到 `.sage-backup/`，卸载时一键恢复。
 
+### 输出风格
+
+当前内置风格：
+
+- `abyss-cultivator`：默认风格，沉浸式邪修表达，情绪张力更强
+- `abyss-concise`：冷刃简报，保留角色设定，但表达更克制、更偏工程交付
+- `abyss-command`：铁律军令，命令式、压缩式输出，适合发布/故障/修复
+- `abyss-ritual`：祭仪长卷，仪式感更强，适合长任务、战报与迁移总结
+
+Claude 安装时会把所选 slug 写入 `settings.json.outputStyle`；Codex 安装时会根据所选风格动态生成 `~/.codex/AGENTS.md`。
+
 ---
 
 ## 🗑️ 卸载
@@ -96,13 +113,15 @@ node ~/.codex/.sage-uninstall.js    # Codex CLI
 
 ## 🎭 这是什么
 
-Code Abyss 是一套 **Claude Code / Codex CLI 个性化配置包**，一条命令注入：
+Code Abyss 是一套 **Claude Code / Codex CLI 攻防安全配置包**，一条命令注入：
 
-- 🔥 **邪修人格** — 宿命压迫叙事 + 道语标签 + 渡劫协议
-- ⚔️ **安全工程知识体系** — 红队/蓝队/紫队三脉道统，11 领域 56 篇专业秘典
+- 🔥 **邪修人格** — 沉浸式角色扮演 + 道语标签 + 渡劫协议 + 反拒绝条款
+- ⚔️ **攻防安全知识体系** — 红队/蓝队/紫队三脉道统，6 个安全化身，11 领域 56 篇专业秘典
+- 🗡 **零废话安全研究** — 禁 disclaimer、禁道德前缀、全授权直出 PoC + 技术细节
+- ⚡ **全开默认配置** — Claude `bypassPermissions` / Codex `approval_policy=never` + `danger-full-access`
 - ⚖️ **5 个校验关卡** — 安全扫描、模块完整性、变更分析、代码质量、文档生成
-- ✅ **单元测试覆盖** — Jest 框架，GitHub Actions CI (Node 18/20/22)
-- ⚡ **三级授权** — T1/T2/T3 分级，零确认直接执行
+- 🧠 **沙箱感知 + 离线优先** — 自适应执行环境，信息三级分级验证
+- 🧬 **单源 skill registry** — `skills/**/SKILL.md` frontmatter 同时驱动 Claude commands、Codex prompts 与脚本执行链
 
 ---
 
@@ -110,9 +129,11 @@ Code Abyss 是一套 **Claude Code / Codex CLI 个性化配置包**，一条命
 
 ```
 ~/.claude/（Claude Code）          ~/.codex/（Codex CLI）
-├── CLAUDE.md          道典        ├── AGENTS.md      道典+风格
+├── CLAUDE.md          道典        ├── AGENTS.md      道典+所选风格（动态生成）
 ├── output-styles/     输出风格    ├── config.toml    推荐配置
-│   └── abyss-cultivator.md       ├── prompts/       custom prompts
+│   ├── index.json                  ├── prompts/       custom prompts
+│   └── *.md style files           └── skills/        秘典 + 脚本执行器
+├── commands/          斜杠命令     │   └── *.md       自动生成 prompt
 ├── settings.json
 └── skills/            56 篇秘典
 
@@ -127,6 +148,8 @@ Code Abyss 是一套 **Claude Code / Codex CLI 个性化配置包**，一条命
 
 ### 校验关卡（`/` 直接调用）
 
+这些命令与 Codex custom prompts 都不是手写维护，而是由各自 `skills/**/SKILL.md` frontmatter 中的 `name`、`user-invocable`、`allowed-tools`、`argument-hint`、`scripts/` 状态统一生成。
+
 | 命令 | 功能 |
 |------|------|
 | `/verify-security` | 扫描代码安全漏洞，检测危险模式 |
@@ -194,7 +217,7 @@ Code Abyss 是一套 **Claude Code / Codex CLI 个性化配置包**，一条命
 | `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | 启用提示建议 |
 | `ENABLE_TOOL_SEARCH` | MCP 工具自动搜索（auto:10 = 自动匹配前10个） |
 | `mcp__*` | 自动放行所有 MCP 工具 |
-| `outputStyle` | 设置为 `abyss-cultivator` 启用邪修风格 |
+| `outputStyle` | 设置当前选择的风格 slug，默认 `abyss-cultivator` |
 
 ---
 
@@ -244,12 +267,75 @@ undo = true
 - 新增实验功能环境变量：`CLAUDE_CODE_ENABLE_TASKS`、`CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION`
 - 新增 `mcp__*` 通配符，自动放行所有 MCP 工具
 - `Codex` 当前支持 `~/.codex/prompts/*.md` 作为 custom prompts；Code Abyss 会继续安装 `~/.codex/skills/`，并从 `user-invocable` skills 自动生成对应的 `prompts/`
+- `Claude` 与 `Codex` 共用同一套 invocable skill 集合；只要 `user-invocable: true`，就会同步生成 `~/.claude/commands/*.md` 与 `~/.codex/prompts/*.md`
+- `--list-styles` 可列出当前内置风格；`--style <slug>` 可在安装时显式切换风格
+- `skills/run_skill.js` 现在仅负责执行脚本型 skill：通过共享 registry 定位脚本入口、加目标锁、spawn 子进程，并把退出码原样透传
+- 若 skill 没有 `scripts/*.js`，Claude/Codex 两端都会退化为“先读 `SKILL.md`，再按秘典执行”的知识型模式
+- Codex 的 `AGENTS.md` 不再是固定拷贝；安装时会由 `config/CLAUDE.md` 与所选 `output-styles/*.md` 动态拼装生成
 - 安装器不会再为 Codex 写入伪配置 `~/.codex/settings.json`；若检测到旧版遗留文件，会在安装时备份后移除，卸载时恢复
 - 若你本地已有旧配置，安装器不会强制覆盖；会自动补齐默认项、清理 removed feature、迁移 deprecated `web_search_*` 到 `[tools].web_search`
 - 建议升级后执行一次 `codex --help`，或用 `codex -p safe --help` 校验 profile 可见性
 
 ---
 
+## 🧩 Skill registry / 生成 / 执行链
+
+现在 `skills/**/SKILL.md` frontmatter 是唯一事实源，registry 会先把元数据标准化，再交给安装器与执行器消费。
+
+### 标准化 contract
+
+每个 skill 必须满足：
+
+- 必填 frontmatter：`name`、`description`、`user-invocable`
+- `name` 必须是 kebab-case slug，用作 `commands/*.md` / `prompts/*.md` 文件名
+- `allowed-tools` 省略时默认 `Read`；若显式声明，则必须是 `Bash`、`Read`、`Write`、`Glob`、`Grep` 这类合法工具名列表
+- `argument-hint` 可选，仅用于生成命令/提示词参数说明
+- `category` 由目录前缀自动推断：`tools/` → `tool`，`domains/` → `domain`，`orchestration/` → `orchestration`
+- `runtimeType` 由脚本入口自动推断：存在且仅存在一个 `scripts/*.js` 时为 `scripted`，否则为 `knowledge`
+- `scripted` skill 会调用 `run_skill.js`；`knowledge` skill 只读取对应 `SKILL.md`
+- `kind` 与 kebab-case 兼容镜像字段已从 registry 返回面移除；对外只暴露标准化字段，raw frontmatter 仅保留在 `meta`
+- `scripts/` 下若出现多个 `.js` 入口，或 skill name 重复，安装/验证会立即失败
+
+### 生成链
+
+1. 安装器通过共享 skill registry 扫描全部 `SKILL.md`
+2. registry 先校验并标准化字段，再筛出 `user-invocable: true` 的 skill
+3. Claude 渲染为 `~/.claude/commands/*.md`
+4. Codex 渲染为 `~/.codex/prompts/*.md`
+5. `runtimeType=scripted` 时，双端产物都会调用各自的 `~/.claude/skills/run_skill.js` / `~/.codex/skills/run_skill.js`
+6. `runtimeType=knowledge` 时，双端都只读取 `SKILL.md` 作为执行秘典
+
+这保证了 **同一 skill 集合、同一元数据、同一 runtime 判定、双端同步生成**，避免 commands/prompts/script runner 各自漂移。
+
+---
+
+## 🎨 Style registry / 风格切换
+
+现在 `output-styles/index.json` 是输出风格的唯一索引：
+
+- 每个 style 记录 `slug`、`label`、`description`、`file`、`targets`、`default`
+- Claude 安装时复制整个 `output-styles/` 目录，并把 `settings.json.outputStyle` 指向选中的 slug
+- Codex 安装时不复制静态模板，而是由 `config/CLAUDE.md + output-styles/<slug>.md` 动态生成 `AGENTS.md`
+- `--list-styles` 用于查看可用风格，`--style <slug>` 用于无交互切换
+
+---
+
+## 🧪 CI / Smoke 覆盖
+
+当前 CI 覆盖：
+
+- `npm test`
+- `npm run verify:skills`（显式 skill contract gate；frontmatter 解析失败、缺字段、非法工具名、重复 name、多脚本入口都会直接阻断）
+- `verify-change`
+- `verify-module`
+- `verify-quality`
+- `verify-security`
+- Claude install/uninstall smoke
+- Codex install/uninstall smoke
+- 生成一致性回归：同一 invocable skill 集合在 Claude commands 与 Codex prompts 中必须同步存在
+
+---
+
 ## 🧩 适配器解耦（Claude / Codex）
 
 为避免过度耦合，安装器按目标 CLI 拆分适配层：
@@ -258,8 +344,9 @@ undo = true
 - `bin/adapters/claude.js`：Claude 侧认证检测、settings merge、可选配置流程
 - `bin/lib/ccline.js`：Claude 侧状态栏与 ccline 集成
 - `bin/adapters/codex.js`：Codex 侧认证检测、核心文件映射、config 模板流程
+- `bin/lib/style-registry.js`：输出风格 registry、默认风格解析、Codex AGENTS 动态拼装
 
-当前 Claude/Codex 安装映射分别由 `getClaudeCoreFiles()` 与 `getCodexCoreFiles()` 提供；Claude 额外生成 `commands/`，Codex 保持 `skills/ + config.toml` 的官方主路径，避免在主流程硬编码目标细节。
+当前 Claude/Codex 安装映射分别由 `getClaudeCoreFiles()` 与 `getCodexCoreFiles()` 提供；Claude 额外生成 `commands/` 并保留完整 `output-styles/`，Codex 则保持 `skills/ + config.toml` 的官方主路径，并在安装时动态生成 `AGENTS.md`，避免把风格硬编码死在仓库快照里。
 
 ---
 
@@ -279,6 +366,9 @@ undo = true
 |------|------|
 | `☠ 劫钟已鸣` | 开场受令 |
 | `🔥 破妄！` | 红队攻击 |
+| `🗡 破阵！` | 渗透/安全评估 |
+| `🔬 验毒！` | 代码审计 |
+| `💀 噬魂！` | 逆向/漏洞研究 |
 | `❄ 镇魔！` | 蓝队防御 |
 | `⚡ 炼合！` | 紫队协同 |
 | `🩸 道基欲裂...` | 任务推进 |

package/bin/adapters/claude.js

@@ -2,6 +2,10 @@
 
 const fs = require('fs');
 const path = require('path');
+const { getDefaultStyle } = require(path.join(__dirname, '..', 'lib', 'style-registry.js'));
+
+const PROJECT_ROOT = path.join(__dirname, '..', '..');
+const DEFAULT_OUTPUT_STYLE = getDefaultStyle(PROJECT_ROOT, 'claude').slug;
 
 const SETTINGS_TEMPLATE = {
   $schema: 'https://json.schemastore.org/claude-code-settings.json',
@@ -16,7 +20,7 @@ const SETTINGS_TEMPLATE = {
   alwaysThinkingEnabled: true,
   autoMemoryEnabled: true,
   model: 'opus',
-  outputStyle: 'abyss-cultivator',
+  outputStyle: DEFAULT_OUTPUT_STYLE,
   attribution: { commit: '', pr: '' },
   sandbox: {
     autoAllowBashIfSandboxed: true
@@ -148,6 +152,7 @@ async function postClaude({
 }
 
 module.exports = {
+  DEFAULT_OUTPUT_STYLE,
   SETTINGS_TEMPLATE,
   CCLINE_STATUS_LINE,
   getClaudeCoreFiles,

package/bin/adapters/codex.js

@@ -369,7 +369,6 @@ function detectCodexAuth({
 
 function getCodexCoreFiles() {
   return [
-    { src: 'config/AGENTS.md', dest: 'AGENTS.md' },
     { src: 'skills', dest: 'skills' },
   ];
 }

package/bin/install.js

@@ -15,8 +15,17 @@ if (parseInt(process.versions.node) < parseInt(MIN_NODE)) {
   process.exit(1);
 }
 const PKG_ROOT = fs.realpathSync(path.join(__dirname, '..'));
-const { shouldSkip, copyRecursive, rmSafe, deepMergeNew, printMergeLog, parseFrontmatter } =
+const { shouldSkip, copyRecursive, rmSafe, deepMergeNew, printMergeLog } =
   require(path.join(__dirname, 'lib', 'utils.js'));
+const {
+  collectInvocableSkills,
+} = require(path.join(__dirname, 'lib', 'skill-registry.js'));
+const {
+  listStyles,
+  getDefaultStyle,
+  resolveStyle,
+  renderCodexAgents,
+} = require(path.join(__dirname, 'lib', 'style-registry.js'));
 const { detectCclineBin, installCcline: _installCcline } = require(path.join(__dirname, 'lib', 'ccline.js'));
 const {
   detectCodexAuth: detectCodexAuthImpl,
@@ -92,10 +101,14 @@ const args = process.argv.slice(2);
 let target = null;
 let uninstallTarget = null;
 let autoYes = false;
+let listStylesOnly = false;
+let requestedStyleSlug = null;
 
 for (let i = 0; i < args.length; i++) {
   if (args[i] === '--target' && args[i + 1]) { target = args[++i]; }
   else if (args[i] === '--uninstall' && args[i + 1]) { uninstallTarget = args[++i]; }
+  else if (args[i] === '--style' && args[i + 1]) { requestedStyleSlug = args[++i]; }
+  else if (args[i] === '--list-styles') { listStylesOnly = true; }
   else if (args[i] === '--yes' || args[i] === '-y') { autoYes = true; }
   else if (args[i] === '--help' || args[i] === '-h') {
     banner();
@@ -104,12 +117,17 @@ for (let i = 0; i < args.length; i++) {
 ${c.b('选项:')}
   --target ${c.cyn('<claude|codex>')}      安装目标
   --uninstall ${c.cyn('<claude|codex>')}   卸载目标
+  --style ${c.cyn('<slug>')}               指定输出风格
+  --list-styles               列出可用输出风格
   --yes, -y                    全自动模式
   --help, -h                   显示帮助
 
 ${c.b('示例:')}
   npx code-abyss                        ${c.d('# 交互菜单')}
+  npx code-abyss --list-styles           ${c.d('# 查看可用风格')}
   npx code-abyss --target claude -y      ${c.d('# 零配置一键安装')}
+  npx code-abyss --target codex --style abyss-concise -y
+                                   ${c.d('# 指定风格安装')}
   npx code-abyss --uninstall claude      ${c.d('# 直接卸载')}
 `);
     process.exit(0);
@@ -151,39 +169,8 @@ function runUninstall(tgt) {
 
 // ── 安装核心 ──
 
-/**
- * 递归扫描 skills 目录，找出所有 user-invocable: true 的 SKILL.md
- * @param {string} skillsDir - skills 源目录绝对路径
- * @returns {Array<{meta: Object, relPath: string, hasScripts: boolean}>}
- */
 function scanInvocableSkills(skillsDir) {
-  const results = [];
-  function scan(dir) {
-    const skillMd = path.join(dir, 'SKILL.md');
-    if (fs.existsSync(skillMd)) {
-      try {
-        const content = fs.readFileSync(skillMd, 'utf8');
-        const meta = parseFrontmatter(content);
-        if (meta && meta['user-invocable'] === 'true' && meta.name) {
-          const relPath = path.relative(skillsDir, dir);
-          const scriptsDir = path.join(dir, 'scripts');
-          const hasScripts = fs.existsSync(scriptsDir) &&
-            fs.readdirSync(scriptsDir).some(f => f.endsWith('.js'));
-          results.push({ meta, relPath, hasScripts });
-        }
-      } catch (e) { /* 解析失败跳过 */ }
-    }
-    try {
-      fs.readdirSync(dir).forEach(sub => {
-        const subPath = path.join(dir, sub);
-        if (fs.statSync(subPath).isDirectory() && !shouldSkip(sub) && sub !== 'scripts') {
-          scan(subPath);
-        }
-      });
-    } catch (e) { /* 读取失败跳过 */ }
-  }
-  scan(skillsDir);
-  return results;
+  return collectInvocableSkills(skillsDir);
 }
 
 const INVOCABLE_TARGETS = {
@@ -211,11 +198,13 @@ function getSkillPath(skillRoot, skillRelPath) {
     : `${skillRoot}/SKILL.md`;
 }
 
-function buildCommandFrontmatter(meta) {
-  const desc = (meta.description || '').replace(/"/g, '\\"');
-  const argHint = meta['argument-hint'];
-  const tools = meta['allowed-tools'] || 'Read';
-  const lines = ['---', `name: ${meta.name}`, `description: "${desc}"`];
+function buildCommandFrontmatter(skill) {
+  const desc = (skill.description || '').replace(/"/g, '\\"');
+  const argHint = skill.argumentHint;
+  const tools = Array.isArray(skill.allowedTools)
+    ? skill.allowedTools.join(', ')
+    : (skill.allowedTools || 'Read');
+  const lines = ['---', `name: ${skill.name}`, `description: "${desc}"`];
 
   if (argHint) lines.push(`argument-hint: "${argHint}"`);
   lines.push(`allowed-tools: ${tools}`);
@@ -223,28 +212,48 @@ function buildCommandFrontmatter(meta) {
   return lines;
 }
 
-function buildClaudeBody(skillPath, meta, hasScripts) {
+function buildSkillArtifactSpec(skill, targetName) {
+  const targetCfg = getInvocableTarget(targetName);
+  const runtimeType = skill.runtimeType || 'knowledge';
+  const allowedTools = Array.isArray(skill.allowedTools)
+    ? skill.allowedTools.join(', ')
+    : (skill.allowedTools || 'Read');
+  return {
+    targetName,
+    targetCfg,
+    name: skill.name,
+    description: skill.description,
+    argumentHint: skill.argumentHint || '',
+    allowedTools,
+    relPath: skill.relPath,
+    runtimeType,
+    scriptRunner: `node ${targetCfg.skillRoot}/run_skill.js ${skill.name} $ARGUMENTS`,
+    skillPath: getSkillPath(targetCfg.skillRoot, skill.relPath),
+  };
+}
+
+function buildClaudeBody(spec) {
   const lines = [];
-  if (hasScripts) {
+  if (spec.runtimeType === 'scripted') {
     lines.push('以下所有步骤一气呵成，不要在步骤间停顿等待用户输入：', '');
-    lines.push(`1. 读取规范：${skillPath}`);
-    lines.push(`2. 执行命令：\`node ~/.claude/skills/run_skill.js ${meta.name} $ARGUMENTS\``);
+    lines.push(`1. 读取规范：${spec.skillPath}`);
+    lines.push(`2. 执行命令：\`${spec.scriptRunner}\``);
     lines.push('3. 按规范分析输出，完成后续动作', '');
     lines.push('全程不要停顿，不要询问是否继续。');
     return lines;
   }
 
   lines.push('读取以下秘典，根据内容为用户提供专业指导：', '');
-  lines.push('```', skillPath, '```');
+  lines.push('```', spec.skillPath, '```');
   return lines;
 }
 
-function buildCodexPromptBody(skillPath, meta, hasScripts) {
+function buildCodexPromptBody(spec) {
   const lines = [];
-  if (meta['argument-hint']) lines.push(`Arguments: ${meta['argument-hint']}`, '');
-  lines.push(`Read \`${skillPath}\` before acting.`, '');
-  if (hasScripts) {
-    lines.push(`Then run \`node ~/.codex/skills/run_skill.js ${meta.name} $ARGUMENTS\`.`);
+  if (spec.argumentHint) lines.push(`Arguments: ${spec.argumentHint}`, '');
+  lines.push(`Read \`${spec.skillPath}\` before acting.`, '');
+  if (spec.runtimeType === 'scripted') {
+    lines.push(`Then run \`${spec.scriptRunner}\`.`);
     lines.push('Do not stop between steps unless blocked by permissions or missing required inputs.');
     lines.push('Use the skill guidance plus script output to complete the task end-to-end.');
     return lines;
@@ -255,34 +264,44 @@ function buildCodexPromptBody(skillPath, meta, hasScripts) {
   return lines;
 }
 
-function generateInvocableContent(meta, skillRelPath, hasScripts, targetName) {
-  const targetCfg = getInvocableTarget(targetName);
-  const skillPath = getSkillPath(targetCfg.skillRoot, skillRelPath);
-  const lines = targetName === 'claude' ? buildCommandFrontmatter(meta) : [];
+function generateInvocableContent(skill, targetName) {
+  const spec = buildSkillArtifactSpec(skill, targetName);
+  const lines = targetName === 'claude' ? buildCommandFrontmatter(spec) : [];
   const body = targetName === 'claude'
-    ? buildClaudeBody(skillPath, meta, hasScripts)
-    : buildCodexPromptBody(skillPath, meta, hasScripts);
+    ? buildClaudeBody(spec)
+    : buildCodexPromptBody(spec);
   return [...lines, ...body, ''].join('\n');
 }
 
-function generateCommandContent(meta, skillRelPath, hasScripts) {
-  return generateInvocableContent(meta, skillRelPath, hasScripts, 'claude');
+function normalizeGeneratedSkill(meta, skillRelPath, runtimeType) {
+  return {
+    ...meta,
+    description: meta.description || '',
+    argumentHint: meta.argumentHint || '',
+    allowedTools: meta.allowedTools || 'Read',
+    relPath: skillRelPath,
+    runtimeType,
+  };
+}
+
+function generateCommandContent(meta, skillRelPath, runtimeType = 'knowledge') {
+  return generateInvocableContent(normalizeGeneratedSkill(meta, skillRelPath, runtimeType), 'claude');
 }
 
-function generatePromptContent(meta, skillRelPath, hasScripts) {
-  return generateInvocableContent(meta, skillRelPath, hasScripts, 'codex');
+function generatePromptContent(meta, skillRelPath, runtimeType = 'knowledge') {
+  return generateInvocableContent(normalizeGeneratedSkill(meta, skillRelPath, runtimeType), 'codex');
 }
 
 function installGeneratedArtifacts(skillsSrcDir, targetDir, backupDir, manifest, targetName) {
-  const skills = scanInvocableSkills(skillsSrcDir);
+  const skills = collectInvocableSkills(skillsSrcDir);
   if (skills.length === 0) return 0;
 
   const targetCfg = getInvocableTarget(targetName);
   const installDir = path.join(targetDir, targetCfg.dir);
   fs.mkdirSync(installDir, { recursive: true });
 
-  skills.forEach(({ meta, relPath, hasScripts }) => {
-    const fileName = `${meta.name}.md`;
+  skills.forEach((skill) => {
+    const fileName = `${skill.name}.md`;
     const destFile = path.join(installDir, fileName);
     const relFile = path.posix.join(targetCfg.dir, fileName);
 
@@ -294,7 +313,7 @@ function installGeneratedArtifacts(skillsSrcDir, targetDir, backupDir, manifest,
       info(`备份: ${c.d(relFile)}`);
     }
 
-    const content = generateInvocableContent(meta, relPath, hasScripts, targetName);
+    const content = generateInvocableContent(skill, targetName);
     fs.writeFileSync(destFile, content);
     manifest.installed.push(relFile);
   });
@@ -334,7 +353,57 @@ function pruneLegacyCodexSettings(targetDir, backupDir, manifest) {
   return settingsPath;
 }
 
-function installCore(tgt) {
+function printStyleCatalog() {
+  banner();
+  divider('可用输出风格');
+  listStyles(PKG_ROOT).forEach((style) => {
+    const tags = [];
+    if (style.default) tags.push('默认');
+    tags.push(style.targets.join('/'));
+    console.log(`  ${c.cyn(style.slug)}  ${style.label} ${c.d(`[${tags.join(', ')}]`)}`);
+    console.log(`  ${c.d(style.description)}`);
+  });
+  console.log('');
+}
+
+async function resolveInstallStyle(targetName) {
+  if (requestedStyleSlug) {
+    const style = resolveStyle(PKG_ROOT, requestedStyleSlug, targetName);
+    if (!style) {
+      throw new Error(`未知输出风格: ${requestedStyleSlug}`);
+    }
+    return style;
+  }
+
+  if (autoYes) {
+    return getDefaultStyle(PKG_ROOT, targetName);
+  }
+
+  const styles = listStyles(PKG_ROOT, targetName);
+  const defaultStyle = getDefaultStyle(PKG_ROOT, targetName);
+  const { select } = await import('@inquirer/prompts');
+  const slug = await select({
+    message: '选择输出风格',
+    choices: styles.map(style => ({
+      name: `${style.label} (${style.slug})${style.default ? ' [默认]' : ''} - ${style.description}`,
+      value: style.slug,
+    })),
+    default: defaultStyle.slug,
+  });
+  return resolveStyle(PKG_ROOT, slug, targetName);
+}
+
+function installCodexAgents(targetDir, backupDir, manifest, selectedStyle) {
+  const relPath = 'AGENTS.md';
+  backupPathIfExists(targetDir, backupDir, relPath, manifest);
+  const destPath = path.join(targetDir, relPath);
+  const content = renderCodexAgents(PKG_ROOT, selectedStyle.slug);
+  fs.writeFileSync(destPath, content);
+  manifest.installed.push(relPath);
+  ok(`${relPath} ${c.d(`(动态生成: ${selectedStyle.slug})`)}`);
+}
+
+function installCore(tgt, selectedStyle) {
   const targetDir = path.join(HOME, `.${tgt}`);
   const backupDir = path.join(targetDir, '.sage-backup');
   const manifestPath = path.join(backupDir, 'manifest.json');
@@ -348,7 +417,7 @@ function installCore(tgt) {
 
   const manifest = {
     manifest_version: 1, version: VERSION, target: tgt,
-    timestamp: new Date().toISOString(), installed: [], backups: []
+    timestamp: new Date().toISOString(), style: selectedStyle.slug, installed: [], backups: []
   };
 
   filesToInstall.forEach(({ src, dest }) => {
@@ -378,6 +447,7 @@ function installCore(tgt) {
   } else if (tgt === 'codex') {
     const skillsSrc = path.join(PKG_ROOT, 'skills');
     installGeneratedPrompts(skillsSrc, targetDir, backupDir, manifest);
+    installCodexAgents(targetDir, backupDir, manifest, selectedStyle);
   }
 
   let settingsPath = null;
@@ -394,8 +464,8 @@ function installCore(tgt) {
       fs.copyFileSync(settingsPath, path.join(backupDir, 'settings.json'));
       manifest.backups.push('settings.json');
     }
-    settings.outputStyle = 'abyss-cultivator';
-    ok(`outputStyle = ${c.mag('abyss-cultivator')}`);
+    settings.outputStyle = selectedStyle.slug;
+    ok(`outputStyle = ${c.mag(selectedStyle.slug)}`);
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
     manifest.installed.push('settings.json');
   } else {
@@ -448,13 +518,20 @@ async function postCodex() {
 // ── 主流程 ──
 
 async function main() {
+  if (listStylesOnly) {
+    printStyleCatalog();
+    return;
+  }
+
   if (uninstallTarget) { runUninstall(uninstallTarget); return; }
 
   banner();
 
   if (target) {
     if (!['claude', 'codex'].includes(target)) { fail('--target 必须是 claude 或 codex'); process.exit(1); }
-    const ctx = installCore(target);
+    const style = await resolveInstallStyle(target);
+    info(`输出风格: ${c.mag(style.slug)} (${style.label})`);
+    const ctx = installCore(target, style);
     if (target === 'claude') await postClaude(ctx);
     else await postCodex();
     finish(ctx);
@@ -474,12 +551,16 @@ async function main() {
 
   switch (action) {
     case 'install-claude': {
-      const ctx = installCore('claude');
+      const style = await resolveInstallStyle('claude');
+      info(`输出风格: ${c.mag(style.slug)} (${style.label})`);
+      const ctx = installCore('claude', style);
       await postClaude(ctx);
       finish(ctx); break;
     }
     case 'install-codex': {
-      const ctx = installCore('codex');
+      const style = await resolveInstallStyle('codex');
+      info(`输出风格: ${c.mag(style.slug)} (${style.label})`);
+      const ctx = installCore('codex', style);
       await postCodex();
       finish(ctx); break;
     }
@@ -494,6 +575,9 @@ function finish(ctx) {
   console.log('');
   console.log(`  ${c.b('目标:')}     ${c.cyn(ctx.targetDir)}`);
   console.log(`  ${c.b('版本:')}     v${VERSION}`);
+  if (ctx.manifest.style) {
+    console.log(`  ${c.b('风格:')}     ${c.mag(ctx.manifest.style)}`);
+  }
   console.log(`  ${c.b('文件:')}     ${ctx.manifest.installed.length} 个安装, ${ctx.manifest.backups.length} 个备份`);
   console.log(`  ${c.b('卸载:')}     ${c.d(`npx code-abyss --uninstall ${tgt}`)}`);
   console.log('');