abelworkflow 1.2.4 → 1.3.0

package/README.md

@@ -1,6 +1,6 @@
 # AbelWorkflow
 
-AbelWorkflow 为 Codex、Claude Code 和 Pi 部署统一的 Skills、工作流命令、Agent 配置与 Pi Extensions。
+AbelWorkflow 为 Claude Code、Codex 和 Pi 配置 CLI 与 API，并为 Pi 部署独立 Skills 与 Extensions。Abel 工作流由 cadence 接管，不再安装到 Codex 或 Claude Code。
 
 ## 环境要求
 
@@ -8,21 +8,17 @@ AbelWorkflow 为 Codex、Claude Code 和 Pi 部署统一的 Skills、工作流
 - npm 10 或兼容版本
 - Linux、macOS 或原生 Windows
 
-## 工作流命令
+## Cadence 工作流
 
-| 命令 | 用途 |
-| --- | --- |
-| `/abel-init` | 初始化 OpenSpec 环境并验证工具链 |
-| `/abel-design` | 将需求整理为可实施、可验证的 OpenSpec 规格 |
-| `/abel-implement` | 按 Red → Green → Refactor 实施变更 |
-| `/abel-diagnose` | 基于证据定位根因并完成回归验证 |
+`abel-*` 工作流已迁移到 Pi 扩展 cadence，本安装器不再安装这些命令或 skills，也不再为 Codex / Claude Code 建立工作流链接。安装/更新 Pi CLI 成功后会自动执行，也可在菜单选择“安装/更新 cadence”单独安装或重试：
 
-```text
-/abel-init → /abel-design → /abel-implement(TDD)
-                           ↘ /abel-diagnose (bug fix)
+```bash
+pi install npm:@abelxiaoxing/cadence
 ```
 
-OpenSpec 命令保持独立：`/opsx:propose`、`/opsx:explore`、`/opsx:apply`、`/opsx:update`、`/opsx:sync`、`/opsx:archive`、`openspec view`、`openspec status`。
+cadence 自带 grok-search、context7 等配置；本安装器不再向 Pi 链接这两个独立 skills。Claude/Codex 的 CLI 安装与 API 配置继续保留，但不安装 `abel-*` 工作流。自动安装 cadence 失败时会提示重试方式，其余配置仍可继续。
+
+配置 Pi API 只部署仓库自带扩展并保存本地配置，不调用 cadence 安装，不要求 `pi` 命令已安装；单独安装 cadence 时需要 `pi` 命令可用。
 
 ## 安装与更新
 
@@ -32,18 +28,18 @@ npx abelworkflow install
 npx abelworkflow@latest
 ```
 
-无 TTY 环境必须显式运行 `npx abelworkflow install`。安装器将工作流部署到 `~/.agents`，再为 Claude、Codex 与 Pi 建立链接。已有目标与托管内容冲突时，安装会失败并保留原内容；确认目标后再处理冲突。
+无 TTY 环境必须显式运行 `npx abelworkflow install`。该命令只刷新已选择的 skills、extensions 和 Pi 链接，不会安装尚未配置的 skill。已有目标与托管内容冲突时，安装会失败并保留原内容；确认目标后再处理冲突。
 
 ### 源码安装
 
+源码开发与验证需要 Node.js 22.19 或更高版本，以满足锁定的 Pi SDK 要求。
+
 源码目录与部署目录必须分离，不能相同或互相嵌套。不要把源码仓库直接克隆到 `~/.agents`。
 
 ```bash
 git clone https://github.com/abelxiaoxing/AbelWorkflow ~/src/AbelWorkflow
 cd ~/src/AbelWorkflow
 npm ci
-npm ci --prefix skills/dev-browser
-npm run build --prefix skills/dev-browser
 node bin/abelworkflow.mjs install --agents-dir ~/.agents
 ```
 
@@ -55,25 +51,26 @@ node .\bin\abelworkflow.mjs install --agents-dir "$HOME\.agents"
 
 ### 可选 Skill 依赖
 
-源码安装需按上方命令在同步前构建 dev-browser。同步后如需使用 dev-browser，还需在部署目录中显式安装运行依赖；Time 独立 CLI 需要 Python 3.9+，Windows 还需 `tzdata` 提供 IANA 时区；Grok 依赖安装到用户自行选择的 Python 环境。普通运行不会自动安装依赖或浏览器：
+Grok 依赖安装到用户自行选择的 Python 环境。普通运行不会自动安装依赖：
 
 ```bash
-npm ci --omit=dev --prefix ~/.agents/skills/dev-browser
-node ~/.agents/skills/dev-browser/node_modules/playwright/cli.js install chromium
-python -m pip install tzdata
 python -m pip install -r skills/grok-search/requirements.txt
 ```
 
-部署后的 Skill 目录在普通运行时按只读处理。显式 Skill 密钥配置会写入部署目录的 `.env`；临时文件、浏览器 profile、虚拟环境和其他运行状态应放在操作系统临时目录或用户数据目录。
+部署后的 Skill 目录在普通运行时按只读处理。显式 Skill 密钥配置会写入部署目录的 `.env`；临时文件、虚拟环境和其他运行状态应放在操作系统临时目录或用户数据目录。
+
+菜单里配置某个 skill 时才会安装对应 skill。grok-search 与 context7 只写入 `~/.agents`，不链到 Pi。
 
 ## 配置行为
 
+本安装器不再分发全局 `AGENTS.md` / `CLAUDE.md` 或工作流命令。旧安装中未修改的托管文件与链接按安装记录清理；用户自建或修改过的文件保留并按既有冲突规则处理。仓库根 `AGENTS.md` 仅约束本项目开发，不参与分发。
+
 - Claude API 配置会合并个人默认模板（`$schema`、`attribution`、`hooks`、`alwaysThinkingEnabled`、`language` 与全局权限白名单），删除已弃用的 `includeCoAuthoredBy`；白名单使用当前任务工具 `TaskCreate`、`TaskGet`、`TaskUpdate`、`TaskList`，缺失项补入默认模板但保留已有权限数组。
 - Claude API 使用 `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` 统一关闭非必要流量并保留 `API_TIMEOUT_MS`，清理重叠的 `DISABLE_TELEMETRY` 与 `DISABLE_ERROR_REPORTING`。
 - Claude API 管理 `ANTHROPIC_BASE_URL`、`ANTHROPIC_API_KEY`，并将所选模型同步到 `ANTHROPIC_MODEL`、Opus/Sonnet/Haiku 默认模型与 `CLAUDE_CODE_SUBAGENT_MODEL`；冲突的 `ANTHROPIC_AUTH_TOKEN` 会被删除，其他用户配置保持不变。
-- Codex 配置以 Codex 最新稳定版为基线，不保留旧版本兼容配置；配置会合并个人默认模板，使用 `approval_policy = "never"` 与 `sandbox_mode = "danger-full-access"` 赋予 Agent 完全权限，同时管理 AbelWorkflow Provider 路由、`OPENAI_API_KEY` 与 `auth_mode`，清理冲突的 `preferred_auth_method`、`temp_env_key` 及目标 Provider 旧路由字段，保留其他认证字段。
+- Codex 配置以 Codex 最新稳定版为基线，不保留旧版本兼容配置；配置会合并个人默认模板，使用 `approval_policy = "never"` 与 `sandbox_mode = "danger-full-access"` 赋予 Agent 完全权限，同时管理 AbelWorkflow Provider 路由、`OPENAI_API_KEY` 与 `auth_mode`，清理冲突的 `preferred_auth_method`、`temp_env_key` 及目标 Provider 旧路由字段。写入 API Key 时重建 `auth.json` 为纯 API Key 状态并删除旧登录认证；清空 API Key 时只移除 API Key 字段和模式标记，已删除的登录凭据不会自动恢复。
 - Pi 配置更新 `abelworkflow` Provider、对应凭据及全局 `defaultProvider`、`defaultModel`，保留其他 Provider 与无关设置。
-- 所有 Provider 在配置结构或路径无法安全合并时直接失败。
+- Provider 在配置根对象、要求为对象的配置节或路径无法安全合并时直接失败。Claude 的 `permissions.allow`、`permissions.deny` 缺失或不是数组时，分别使用默认工具白名单和空拒绝列表；已有数组保持不变。
 - Skill 密钥写入 `~/.agents/skills/<skill>/.env`，属于用户私密配置。
 - `.skill-lock.json` 完全属于用户：安装器不读取、不修改、不备份、不删除，也不会将其放入发布包。
 - 自定义 CA 应通过标准证书环境变量显式配置，不关闭 TLS 校验。
@@ -90,11 +87,15 @@ Codex 根据 Provider Base URL 推导 WebSocket 地址。例如，`https://relay
 
 | 托管内容 | Claude Code | Codex | Pi |
 | --- | --- | --- | --- |
-| 工作流 AGENTS 模板 | `~/.claude/CLAUDE.md` | `~/.codex/AGENTS.md` | `~/.pi/agent/AGENTS.md` |
-| `skills/<skill>/` | `~/.claude/skills/<skill>/` | `~/.codex/skills/<skill>/` | `~/.pi/agent/skills/<skill>/` |
-| `abel-*.md` 命令 | `~/.claude/commands/` | `~/.codex/prompts/` | `~/.pi/agent/prompts/` |
+| `abel-*` 工作流 | — | — | cadence |
+| 独立 skills / 密钥配置 | 菜单中配置 CLI 与 API | 菜单中配置 CLI 与 API | 配置 skill 后写入 `~/.agents`；grok-search / context7 不链到 Pi |
+| cadence | — | — | 通过 `pi install npm:@abelxiaoxing/cadence` 安装 |
 | `extensions/*` | — | — | `~/.agents/extensions/` → `~/.pi/agent/extensions/` |
 
+## 开发验证
+
+`npm run check` 执行全部测试及类型检查。`npm run typecheck` 独立检查 `extensions/**/*.ts`，依据锁定的 Pi SDK `0.85.1` 验证接口；Node 测试还会使用真实 SDK 在临时目录加载扩展并检查事件注册，不访问个人配置或请求模型。SDK 和 TypeScript 仅为开发依赖。
+
 ## 自签名 HTTPS 中转
 
 取得中转的 CA PEM 后，在启动客户端前配置：

package/extensions/gpt-responses-compat.ts

@@ -267,7 +267,7 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("session_before_compact", async (event, ctx) => {
     const model = ctx.model;
-    if (!isCompatibleResponsesModel(model)) return;
+    if (!model || !isCompatibleResponsesModel(model)) return;
 
     const { preparation } = event;
     const conversation = serializeConversation([

package/lib/cli/main.mjs

@@ -4,6 +4,7 @@ import * as p from "@clack/prompts";
 import c from "picocolors";
 import { assertInteractiveMenuSupported, parseArgs } from "./args.mjs";
 import * as promptApi from "./prompts.mjs";
+import { createPiActions } from "./pi.mjs";
 import {
   ensurePiExtensionsPresent,
   ensureSkillPresent,
@@ -19,18 +20,16 @@ import {
 } from "../installer/state.mjs";
 import { configureClaudeApi } from "../providers/claude.mjs";
 import { configureCodexApi } from "../providers/codex.mjs";
-import { configurePiApi } from "../providers/pi.mjs";
 import {
   configureContext7Env,
   configureGrokSearchEnv
 } from "../providers/skills.mjs";
-import { commandExists, installCliTool } from "../tools/cli-installer.mjs";
+import { installCliTool } from "../tools/cli-installer.mjs";
 import { createPaths, defaultPaths, pathToLabel } from "../paths.mjs";
 
 const {
   buildCliToolMenuDescriptors,
   CancelledError,
-  confirmOrCancel,
   interactiveMenuDefaultValue,
   interactiveMenuDescriptors
 } = promptApi;
@@ -91,7 +90,7 @@ function presentInstallReport(report, reportOutput) {
 
 function assertNoInstallConflicts(report) {
   if (uniqueReportPaths(report.conflicts).length > 0) {
-    throw new Error("工作流安装存在冲突");
+    throw new Error("托管资源安装存在冲突");
   }
 }
 
@@ -130,7 +129,7 @@ ${c.bold("Usage:")}
 
 ${c.bold("Default behavior:")}
   - npx abelworkflow: open the interactive setup menu.
-  - npx abelworkflow install: sync managed files and links explicitly.
+  - npx abelworkflow install: sync already selected skills, extensions, and Pi links.
 `);
 }
 
@@ -164,71 +163,9 @@ async function configureClaudeForPaths(paths) {
   await configureClaudeApi(paths, promptApi);
 }
 
-async function runFullInit(options, runtime = {}) {
-  const operations = {
-    installWorkflow: () => runManagedInstall({
-      paths: options.paths,
-      force: options.force
-    }),
-    confirm: confirmOrCancel,
-    commandExists,
-    installClaude: () => installCliTool("claude", promptApi),
-    configureClaude: () => configureClaudeForPaths(options.paths),
-    installCodex: () => installCliTool("codex", promptApi),
-    configureCodex: () => configureCodexForPaths(options.paths),
-    installPi: () => installCliTool("pi", promptApi),
-    configurePi: () => configurePiApi(
-      options.paths,
-      ensurePiExtensionsPresentWithReport,
-      promptApi
-    ),
-    configureGrok: () => configureGrokSearchEnv(
-      options.paths,
-      (paths, continuation) => ensureSkillPresentWithReport(paths, "grok-search", continuation),
-      promptApi
-    ),
-    configureContext7: () => configureContext7Env(
-      options.paths,
-      (paths, continuation) => ensureSkillPresentWithReport(paths, "context7-auto-research", continuation),
-      promptApi
-    ),
-    success: (message) => p.log.success(message),
-    ...runtime
-  };
-
-  await operations.installWorkflow();
-
-  if (await operations.confirm({ message: "是否安装或更新 Claude Code CLI？", initialValue: false })) {
-    await operations.installClaude();
-  }
-  if (await operations.confirm({ message: "是否配置 Claude Code 第三方 API？", initialValue: operations.commandExists("claude") })) {
-    await operations.configureClaude();
-  }
-  if (await operations.confirm({ message: "是否安装或更新 Codex CLI？", initialValue: false })) {
-    await operations.installCodex();
-  }
-  if (await operations.confirm({ message: "是否配置 Codex 第三方 API？", initialValue: operations.commandExists("codex") })) {
-    await operations.configureCodex();
-  }
-  if (await operations.confirm({ message: "是否安装或更新 Pi CLI？", initialValue: false })) {
-    await operations.installPi();
-  }
-  if (await operations.confirm({ message: "是否配置 Pi 当前有效 Provider API？", initialValue: operations.commandExists("pi") })) {
-    await operations.configurePi();
-  }
-  if (await operations.confirm({ message: "是否填写 grok-search 环境变量？", initialValue: false })) {
-    await operations.configureGrok();
-  }
-  if (await operations.confirm({ message: "是否填写 context7-auto-research 环境变量？", initialValue: false })) {
-    await operations.configureContext7();
-  }
-
-  operations.success(c.green("AbelWorkflow 完整初始化完成"));
-}
-
 async function runInteractiveMenu(options) {
   p.intro(c.bold(c.bgCyan(c.black(" AbelWorkflow Setup "))));
-  p.log.message(`工作流目录: ${c.cyan(pathToLabel(options.agentsDir))}`);
+  p.log.message(`托管目录: ${c.cyan(pathToLabel(options.agentsDir))}`);
 
   const buildOption = (d) => {
     const opt = { value: d.value, label: d.label };
@@ -237,15 +174,13 @@ async function runInteractiveMenu(options) {
     }
     return opt;
   };
+  const pi = createPiActions(options.paths, ensurePiExtensionsPresentWithReport);
   const cliToolMenus = {
     pi: {
       title: "Pi",
-      install: () => installCliTool("pi", promptApi),
-      configure: () => configurePiApi(
-        options.paths,
-        ensurePiExtensionsPresentWithReport,
-        promptApi
-      )
+      install: pi.install,
+      configure: pi.configure,
+      cadence: pi.cadence
     },
     codex: {
       title: "Codex",
@@ -262,7 +197,8 @@ async function runInteractiveMenu(options) {
     const menu = cliToolMenus[tool];
     const actions = {
       [`${tool}-api`]: menu.configure,
-      [`${tool}-install`]: menu.install
+      [`${tool}-install`]: menu.install,
+      ...(tool === "pi" ? { "pi-cadence": menu.cadence } : {})
     };
     while (true) {
       const choice = await p.select({
@@ -280,15 +216,15 @@ async function runInteractiveMenu(options) {
         p.log.warn(`未知 CLI 工具菜单选项: ${choice}`);
         continue;
       }
-      await action();
+      try {
+        await action();
+      } catch (error) {
+        if (choice !== "pi-cadence") throw error;
+        p.log.warn(`cadence 安装失败：${error.message || String(error)}。可再次选择此项重试。`);
+      }
     }
   };
   const menuActions = {
-    "full-init": async () => runFullInit(options),
-    install: async () => runManagedInstall({
-      paths: options.paths,
-      force: options.force
-    }),
     "grok-search": async () => configureGrokSearchEnv(options.paths, (paths, continuation) => ensureSkillPresentWithReport(paths, "grok-search", continuation), promptApi),
     context7: async () => configureContext7Env(options.paths, (paths, continuation) => ensureSkillPresentWithReport(paths, "context7-auto-research", continuation), promptApi),
     "pi-cli": async () => runCliToolMenu("pi"),
@@ -298,9 +234,6 @@ async function runInteractiveMenu(options) {
 
   while (true) {
     const selectOptions = [
-      ...interactiveMenuDescriptors
-        .filter((d) => d.group === "main")
-        .map(buildOption),
       { value: "__sep_skills__", label: "─── 技能配置 ───", disabled: true },
       ...interactiveMenuDescriptors
         .filter((d) => d.group === "skill")
@@ -404,6 +337,5 @@ export {
   assertNoInstallConflicts,
   configureProviderWithMetadata,
   main,
-  presentInstallReport,
-  runFullInit
+  presentInstallReport
 };

package/lib/cli/pi.mjs

@@ -0,0 +1,43 @@
+import * as p from "@clack/prompts";
+import * as promptApi from "./prompts.mjs";
+import { promptPiConfiguration, persistPiConfiguration } from "../providers/pi.mjs";
+import { installCadence, installCliTool } from "../tools/cli-installer.mjs";
+
+function createPiActions(paths, withExtensionsPresent, runtime = {}) {
+  const operations = {
+    withExtensionsPresent,
+    installCli: () => installCliTool("pi", promptApi),
+    installCadence,
+    warn: (message) => p.log.warn(message),
+    success: (message) => p.log.success(message),
+    promptConfiguration: () => promptPiConfiguration(paths, promptApi),
+    persistConfiguration: (intent) => persistPiConfiguration(paths, intent),
+    ...runtime
+  };
+  async function cadence() {
+    await operations.installCadence();
+    operations.success("cadence 安装/更新完成");
+  }
+
+  return {
+    async install() {
+      if (!await operations.installCli()) return { cadenceFailed: false };
+      try {
+        await cadence();
+        return { cadenceFailed: false };
+      } catch (error) {
+        operations.warn(`Pi CLI 已安装，cadence 安装失败：${error.message || String(error)}。可选择“安装/更新 cadence”重试；API 配置仍可继续。`);
+        return { cadenceFailed: true };
+      }
+    },
+    cadence,
+    configure: () => operations.withExtensionsPresent(paths, async (guard) => {
+      await guard();
+      const intent = await operations.promptConfiguration();
+      await guard();
+      await operations.persistConfiguration(intent);
+    })
+  };
+}
+
+export { createPiActions };

package/lib/cli/prompts.mjs

@@ -1,8 +1,6 @@
 import * as p from "@clack/prompts";
 
 const interactiveMenuDescriptors = [
-  { value: "full-init", label: "完整初始化", hint: "同步 + 安装 + 配置", group: "main" },
-  { value: "install", label: "仅同步工作流", group: "main" },
   { value: "grok-search", label: "配置 grok-search", hint: "技能", group: "skill" },
   { value: "context7", label: "配置 context7-auto-research", hint: "技能", group: "skill" },
   { value: "pi-cli", label: "配置/安装 Pi", hint: "CLI", group: "cli" },
@@ -10,12 +8,13 @@ const interactiveMenuDescriptors = [
   { value: "claude-cli", label: "配置/安装 Claude Code", hint: "CLI", group: "cli" },
   { value: "exit", label: "退出", group: "exit" }
 ];
-const interactiveMenuDefaultValue = "full-init";
+const interactiveMenuDefaultValue = "pi-cli";
 const cliToolLabels = {
   pi: "Pi",
   codex: "Codex",
   claude: "Claude Code"
 };
+
 class CancelledError extends Error {
   constructor(message = "用户取消") {
     super(message);
@@ -29,6 +28,7 @@ function buildCliToolMenuDescriptors(tool) {
   return [
     { value: `${tool}-api`, label: `配置 ${label} API` },
     { value: `${tool}-install`, label: `安装/更新 ${label}` },
+    ...(tool === "pi" ? [{ value: "pi-cadence", label: "安装/更新 cadence" }] : []),
     { value: "back", label: "返回上一级" }
   ];
 }

package/lib/installer/assets.mjs

@@ -19,12 +19,6 @@ const ignoredSkillPathPatterns = [
   /(^|\/)build(\/|$)/u
 ];
 
-const devBrowserRuntimePathPatterns = [
-  /^dev-browser\/SKILL\.md$/u,
-  /^dev-browser\/package[^/]*\.json$/u,
-  /^dev-browser\/(?:dist|references)(?:\/|$)/u
-];
-
 function normalizeRelativePath(path) {
   return path.replaceAll("\\", "/");
 }
@@ -72,13 +66,26 @@ function mapGitignoreTemplate(relativePath) {
   return relativePath.replace(/(^|\/)gitignore\.template$/u, "$1.gitignore");
 }
 
-function shouldCopySkillPath(skillsRoot, sourcePath) {
+function selectedSkillNames(previousManagedFiles = {}, pathPrefix = null) {
+  const names = new Set();
+  if (typeof pathPrefix === "string" && pathPrefix.startsWith("skills/")) {
+    const selected = pathPrefix.slice("skills/".length).split("/")[0];
+    if (selected) names.add(selected);
+  }
+  for (const relativePath of Object.keys(previousManagedFiles)) {
+    if (!relativePath.startsWith("skills/")) continue;
+    const skillName = relativePath.slice("skills/".length).split("/")[0];
+    if (skillName) names.add(skillName);
+  }
+  return names;
+}
+
+function shouldCopySkillPath(skillsRoot, sourcePath, selectedSkills) {
   const relativePath = normalizeRelativePath(relative(skillsRoot, sourcePath));
   if (!relativePath) return true;
-  if (relativePath === "dev-browser") return true;
-  if (relativePath.startsWith("dev-browser/")) {
-    return devBrowserRuntimePathPatterns.some((pattern) => pattern.test(relativePath));
-  }
+  const skillName = relativePath.split("/")[0];
+  if (selectedSkills && !selectedSkills.has(skillName)) return false;
+  if (relativePath.startsWith("abel-")) return false;
   if (/(^|\/)dist(\/|$)/u.test(relativePath)) return false;
   return !ignoredSkillPathPatterns.some((pattern) => pattern.test(relativePath));
 }
@@ -115,32 +122,29 @@ async function collectFiles(root, outputPrefix, { filter, mapTargetPath } = {})
 }
 
 async function addAssetTree(manifest, root, outputPrefix, options = {}) {
-  if (!(await pathTargetExists(root))) {
-    if (options.required) throw new Error(`Missing managed asset root: ${root}`);
-    return;
-  }
+  if (!(await pathTargetExists(root))) return;
   for (const [key, value] of await collectFiles(root, outputPrefix, options)) manifest.set(key, value);
 }
 
-async function collectManagedAssets(paths) {
+async function collectManagedAssets(paths, { previousManagedFiles = {}, pathPrefix = null } = {}) {
   const manifest = new Map();
-  await addAssetTree(manifest, paths.workflowTemplateRoot, "", {
-    required: true,
-    mapTargetPath: mapGitignoreTemplate
-  });
-
-  const readmePath = join(paths.packageRoot, "README.md");
-  if (!(await pathTargetExists(readmePath))) throw new Error(`Missing managed asset: ${readmePath}`);
-  const readmeContent = await fs.readFile(readmePath);
-  manifest.set("README.md", {
-    content: readmeContent,
-    hash: hashBytes(readmeContent),
-    mode: (await fs.stat(readmePath)).mode & 0o777
-  });
+  for (const [sourcePath, targetPath] of [
+    [join(paths.packageRoot, "README.md"), "README.md"],
+    [join(paths.packageRoot, "lib/templates/gitignore.template"), ".gitignore"]
+  ]) {
+    if (!(await pathTargetExists(sourcePath))) throw new Error(`Missing managed asset: ${sourcePath}`);
+    const content = await fs.readFile(sourcePath);
+    manifest.set(targetPath, {
+      content,
+      hash: hashBytes(content),
+      mode: (await fs.stat(sourcePath)).mode & 0o777
+    });
+  }
 
+  const selectedSkills = selectedSkillNames(previousManagedFiles, pathPrefix);
   const skillsRoot = join(paths.packageRoot, "skills");
   await addAssetTree(manifest, skillsRoot, "skills", {
-    filter: shouldCopySkillPath,
+    filter: (root, sourcePath) => shouldCopySkillPath(root, sourcePath, selectedSkills),
     mapTargetPath: mapGitignoreTemplate
   });
   await addAssetTree(manifest, join(paths.packageRoot, "extensions"), "extensions");
@@ -264,7 +268,7 @@ async function syncManagedFiles({
   const packageVersion = await readPackageVersion(paths);
   const previousMetadata = await readInstallMetadata(paths);
   const previousManagedFiles = await readManagedFiles(paths, previousMetadata);
-  const manifest = await collectManagedAssets(paths);
+  const manifest = await collectManagedAssets(paths, { previousManagedFiles, pathPrefix });
   const report = createInstallReport();
   const managedFiles = pathPrefix ? { ...previousManagedFiles } : {};
 

package/lib/installer/install.mjs

@@ -3,10 +3,9 @@ import { join } from "node:path";
 import { createPaths } from "../paths.mjs";
 import { readPackageVersion, syncManagedFiles } from "./assets.mjs";
 import {
-  linkClaude,
-  linkCodex,
   linkPi,
-  linkPiExtensions
+  linkPiExtensions,
+  linkPiSkill
 } from "./links.mjs";
 import { withDeploymentLock } from "./lock.mjs";
 import {
@@ -139,9 +138,10 @@ async function installWorkflowLocked(paths, options, guard) {
     onResult: (result) => linkResults.push(result)
   };
   try {
-    await linkClaude(paths, previousLinkedTargets, linkOptions);
-    await linkCodex(paths, previousLinkedTargets, linkOptions);
-    await linkPi(paths, previousLinkedTargets, linkOptions);
+    await linkPi(paths, previousLinkedTargets, {
+      ...linkOptions,
+      managedFiles: assetResult.managedFiles
+    });
   } catch (error) {
     await writeInstallState(
       paths,
@@ -171,6 +171,7 @@ async function installWorkflow(options) {
 async function ensureSkillPresentLocked(paths, validatedName, guard) {
   await guard();
   const previousMetadata = await readInstallMetadata(paths);
+  const previousLinkedTargets = previousMetadata.linkedTargets ?? {};
   const markIncomplete = onceAsync(() => writeIncompleteInstallState(paths, previousMetadata, guard));
   const beforeMutation = async () => {
     await guard();
@@ -188,16 +189,35 @@ async function ensureSkillPresentLocked(paths, validatedName, guard) {
     await markIncomplete();
     throw error;
   }
+  const linkResults = [];
+  try {
+    await linkPiSkill(paths, validatedName, previousLinkedTargets, {
+      force: false,
+      beforeMutation,
+      onResult: (result) => linkResults.push(result),
+      managedFiles: assetResult.managedFiles
+    });
+  } catch (error) {
+    await writeInstallState(
+      paths,
+      assetResult,
+      mergeLinkedTargets(previousLinkedTargets, linkResults),
+      false,
+      guard
+    );
+    throw error;
+  }
+  const report = mergeInstallReports(assetResult.report, reportFromLinkResults(linkResults));
   await writeInstallState(
     paths,
     assetResult,
-    previousMetadata.linkedTargets ?? {},
+    mergeLinkedTargets(previousLinkedTargets, linkResults),
     previousMetadata.workflowInstalled === true
       && previousMetadata.packageVersion === assetResult.packageVersion
-      && assetResult.report.conflicts.length === 0,
+      && report.conflicts.length === 0,
     guard
   );
-  return assetResult.report;
+  return report;
 }
 
 async function ensureSkillPresent(inputPaths, skillName, continuation) {