abelworkflow 1.0.0-rc.1 → 1.1.0

package/README.md

@@ -13,19 +13,18 @@ AbelWorkflow 为 Codex、Claude Code 和 Pi 部署统一的 Skills、工作流
 | 命令 | 用途 |
 | --- | --- |
 | `/abel-init` | 初始化 OpenSpec 环境并验证工具链 |
-| `/abel-research` | 研究需求并生成约束，不实施代码 |
-| `/abel-plan` | 将已确认变更细化为可执行计划 |
+| `/abel-design` | 通过双闸门澄清生成可实施、可验证规格 |
 | `/abel-implement` | 按强制 TDD 实施已批准变更 |
 | `/abel-diagnose` | 进行根因分析、回归测试和批量修复 |
 
 工作流：
 
 ```text
-/abel-init → /abel-research → /abel-plan → /abel-implement(TDD)
-                                      ↘ /abel-diagnose (bug fix)
+/abel-init → /abel-design → /abel-implement(TDD)
+                           ↘ /abel-diagnose (bug fix)
 ```
 
-OpenSpec 命令保持独立：`/opsx:new`、`/opsx:ff`、`/opsx:archive`、`openspec view`、`openspec status`。
+OpenSpec 命令保持独立：`/opsx:propose`、`/opsx:explore`、`/opsx:apply`、`/opsx:update`、`/opsx:sync`、`/opsx:archive`、`openspec view`、`openspec status`。
 
 ## 安装与更新
 
@@ -62,10 +61,10 @@ node .\bin\abelworkflow.mjs install --agents-dir "$HOME\.agents"
 
 ## 配置行为
 
-- Claude 默认使用 `standard` 权限档，不预授权 Bash、Write 或 Edit；只有用户明确选择 `trusted` 才增加宽权限。已有 permissions、deny、hooks 和 timeout 保持不变。
+- Claude 配置默认写入 `bypassPermissions` 全权限模式（YOLO），第三方 API 仅使用 API Key 认证，不添加任何 MCP 权限。已有 permissions、deny、hooks 和 timeout 保持不变。
 - Codex 只更新 AbelWorkflow 管理的认证字段，保留未知字段、其他 Provider 和用户 token。
-- Pi 0.80.0 及以上版本将 GPT API Key 保存在 `~/.pi/agent/auth.json`；`models.json` 只保留模型定义。旧 models-only key 会按先写 auth、后删除旧 key 的顺序迁移。
-- Grok 默认模型统一为 `grok-4.20-auto`。
+- Pi 0.80.0 及以上版本按无会话启动时实际选中的当前有效 Provider 配置 API，并将其 API Key 保存在 `~/.pi/agent/auth.json`；`models.json` 只保留模型定义。旧 models-only key 会按先写 auth、后删除旧 key 的顺序迁移。
+- Grok 默认模型统一为 `grok-4.20-non-reasoning`。
 - Context7 使用显式 CommonJS 入口 `context7-api.cjs`。
 - dev-browser 发布运行时使用 Node ESM 编译产物，入口为 `node dist/scripts/start.js`，不依赖 Bun 或运行时 `npx tsx`。
 - skill 密钥写入 `~/.agents/skills/<skill>/.env`；这些文件属于私密配置。

package/extensions/pi-gpt-responses-compat/index.ts

@@ -21,7 +21,7 @@ export default function (pi: ExtensionAPI) {
   pi.on("before_provider_request", (event, ctx) => {
     const payload = event.payload as any;
     if (!payload || typeof payload !== "object" || Array.isArray(payload)) return;
-    if (ctx.model?.provider !== "gpt") return;
+    if (ctx.model?.api !== "openai-responses") return;
     if (!("input" in payload)) return;
 
     const input = Array.isArray(payload.input) ? payload.input : [];

package/lib/cli/args.mjs

@@ -1,4 +1,4 @@
-function parseArgs(argv, { defaultAgentsDir, resolvePath }) {
+function parseArgs(argv, { defaultAgentsDir, resolvePath, env = process.env }) {
   const options = {
     agentsDir: defaultAgentsDir,
     force: false,
@@ -60,7 +60,7 @@ function parseArgs(argv, { defaultAgentsDir, resolvePath }) {
   if (options.command !== "install" && (options.force || options.relinkOnly || options.agentsDir !== defaultAgentsDir)) {
     throw new Error("`--force`、`--link-only`、`--agents-dir` 仅能与 `install` 命令一起使用");
   }
-  if (!options.nonInteractive && process.env.CI) options.nonInteractive = true;
+  if (!options.nonInteractive && env.CI) options.nonInteractive = true;
   return options;
 }
 

package/lib/cli/main.mjs

@@ -6,28 +6,23 @@ import { assertInteractiveMenuSupported, parseArgs } from "./args.mjs";
 import * as promptApi from "./prompts.mjs";
 import {
   ensurePiResourcesLinked,
-  ensureWorkflowPresent,
+  ensureSkillPresent,
   installManagedWorkflow,
   packageVersionFor
 } from "../installer/install.mjs";
 import {
   finalizeProviderInstallMetadata,
-  getPreviousClaudePermissionProfile,
   getPreviousManagedCodexAgentFiles,
   getPreviousManagedCodexAuthKeys,
   readInstallMetadata,
   writeInstallMetadata
 } from "../installer/state.mjs";
-import {
-  configureClaudeApi,
-  getPreviousManagedClaudePermissions
-} from "../providers/claude.mjs";
+import { configureClaudeApi } from "../providers/claude.mjs";
 import { configureCodexApi } from "../providers/codex.mjs";
 import { configurePiApi } from "../providers/pi.mjs";
 import {
   configureContext7Env,
-  configureGrokSearchEnv,
-  configurePromptEnhancerEnv
+  configureGrokSearchEnv
 } from "../providers/skills.mjs";
 import { commandExists, installCliTool } from "../tools/cli-installer.mjs";
 import { createPaths, defaultPaths, pathToLabel } from "../paths.mjs";
@@ -36,11 +31,8 @@ const {
   buildCliToolMenuDescriptors,
   CancelledError,
   confirmOrCancel,
-  getClaudePermissionProfilePromptOptions,
-  getAugmentContextEnginePromptOptions,
   interactiveMenuDefaultValue,
-  interactiveMenuDescriptors,
-  selectOrCancel
+  interactiveMenuDescriptors
 } = promptApi;
 
 const installReportSummaryFields = [
@@ -66,6 +58,19 @@ function presentInstallReport(report, reportOutput) {
     .map(([label, field]) => `${label} ${pathsByField[field].length}`)
     .join("，")}`);
 
+  for (const [message, field] of [
+    ["已更新", "updated"],
+    ["已跳过", "unchanged"]
+  ]) {
+    const paths = pathsByField[field];
+    if (paths.length > 0) {
+      reportOutput.message([
+        `${message} ${paths.length} 个${field === "unchanged" ? "未变化" : ""}文件：`,
+        ...paths.map((path) => `- ${path}`)
+      ].join("\n"));
+    }
+  }
+
   const conflictPaths = pathsByField.conflicts;
   const conflictSet = new Set(conflictPaths);
   const preservedPaths = pathsByField.preserved.filter((path) => !conflictSet.has(path));
@@ -90,6 +95,18 @@ async function runManagedInstall(options) {
   return report;
 }
 
+async function ensureSkillPresentWithReport(paths, skillName) {
+  const report = await ensureSkillPresent(paths, skillName);
+  presentInstallReport(report, p.log);
+  return report;
+}
+
+async function ensurePiResourcesLinkedWithReport(paths) {
+  const report = await ensurePiResourcesLinked(paths);
+  presentInstallReport(report, p.log);
+  return report;
+}
+
 function printHelp() {
   console.log(`${c.bold("AbelWorkflow")} ${c.cyan("installer")}
 
@@ -129,33 +146,18 @@ async function configureCodexForPaths(paths) {
 async function configureClaudeForPaths(paths) {
   const metadata = await readInstallMetadata(paths);
   const packageVersion = await packageVersionFor(paths, metadata);
-  const permissionProfile = await selectOrCancel(getClaudePermissionProfilePromptOptions(
-    getPreviousClaudePermissionProfile(metadata)
-  ));
-  const result = await configureClaudeApi(paths, promptApi, {
-    permissionProfile,
-    previousManagedPermissions: getPreviousManagedClaudePermissions(metadata)
-  });
+  await configureClaudeApi(paths, promptApi);
   await writeInstallMetadata(paths, finalizeProviderInstallMetadata({
     previousMetadata: metadata,
-    packageVersion,
-    overrides: {
-      claudePermissionProfile: result.permissionProfile,
-      managedClaudePermissions: result.managedPermissions
-    }
+    packageVersion
   }));
 }
 
 async function runFullInit(options) {
-  const augmentContextEngine = options.nonInteractive
-    ? false
-    : await confirmOrCancel(getAugmentContextEnginePromptOptions());
-
   const installReport = await runManagedInstall({
     paths: options.paths,
     force: options.force,
-    relinkOnly: false,
-    featureOverrides: { augmentContextEngine }
+    relinkOnly: false
   });
 
   if (await confirmOrCancel({ message: "是否安装或更新 Claude Code CLI？", initialValue: false })) {
@@ -173,17 +175,14 @@ async function runFullInit(options) {
   if (await confirmOrCancel({ message: "是否安装或更新 Pi CLI？", initialValue: false })) {
     await installCliTool("pi", promptApi);
   }
-  if (await confirmOrCancel({ message: "是否配置 Pi gpt 自定义 API？", initialValue: commandExists("pi") })) {
+  if (await confirmOrCancel({ message: "是否配置 Pi 当前有效 Provider API？", initialValue: commandExists("pi") })) {
     await configurePiApi(options.paths, ensurePiResourcesLinked, promptApi);
   }
   if (await confirmOrCancel({ message: "是否填写 grok-search 环境变量？", initialValue: false })) {
-    await configureGrokSearchEnv(options.paths, ensureWorkflowPresent, promptApi);
+    await configureGrokSearchEnv(options.paths, (paths) => ensureSkillPresent(paths, "grok-search"), promptApi);
   }
   if (await confirmOrCancel({ message: "是否填写 context7-auto-research 环境变量？", initialValue: false })) {
-    await configureContext7Env(options.paths, ensureWorkflowPresent, promptApi);
-  }
-  if (await confirmOrCancel({ message: "是否填写 prompt-enhancer 环境变量？", initialValue: false })) {
-    await configurePromptEnhancerEnv(options.paths, ensureWorkflowPresent, promptApi);
+    await configureContext7Env(options.paths, (paths) => ensureSkillPresent(paths, "context7-auto-research"), promptApi);
   }
 
   const conflictCount = uniqueReportPaths(installReport.conflicts).length;
@@ -211,7 +210,7 @@ async function runInteractiveMenu(options) {
       title: "Pi",
       actions: {
         "pi-install": async () => installCliTool("pi", promptApi),
-        "pi-api": async () => configurePiApi(options.paths, ensurePiResourcesLinked, promptApi)
+        "pi-api": async () => configurePiApi(options.paths, ensurePiResourcesLinkedWithReport, promptApi)
       }
     },
     "codex-cli": {
@@ -236,7 +235,7 @@ async function runInteractiveMenu(options) {
       const choice = await p.select({
         message: `请选择 ${title} 操作`,
         options: buildCliToolMenuDescriptors(tool).map(buildOption),
-        initialValue: `${tool}-install`
+        initialValue: `${tool}-api`
       });
 
       if (p.isCancel(choice) || choice === "back") {
@@ -258,9 +257,8 @@ async function runInteractiveMenu(options) {
       force: options.force,
       relinkOnly: options.relinkOnly
     }),
-    "grok-search": async () => configureGrokSearchEnv(options.paths, ensureWorkflowPresent, promptApi),
-    context7: async () => configureContext7Env(options.paths, ensureWorkflowPresent, promptApi),
-    "prompt-enhancer": async () => configurePromptEnhancerEnv(options.paths, ensureWorkflowPresent, promptApi),
+    "grok-search": async () => configureGrokSearchEnv(options.paths, (paths) => ensureSkillPresentWithReport(paths, "grok-search"), promptApi),
+    context7: async () => configureContext7Env(options.paths, (paths) => ensureSkillPresentWithReport(paths, "context7-auto-research"), promptApi),
     "pi-cli": async () => runCliToolMenu(cliToolMenus["pi-cli"]),
     "codex-cli": async () => runCliToolMenu(cliToolMenus["codex-cli"]),
     "claude-cli": async () => runCliToolMenu(cliToolMenus["claude-cli"])

package/lib/cli/prompts.mjs

@@ -5,35 +5,29 @@ const interactiveMenuDescriptors = [
   { value: "install", label: "仅同步工作流", group: "main" },
   { value: "grok-search", label: "配置 grok-search", hint: "技能", group: "skill" },
   { value: "context7", label: "配置 context7-auto-research", hint: "技能", group: "skill" },
-  { value: "prompt-enhancer", label: "配置 prompt-enhancer", hint: "技能", group: "skill" },
-  { value: "pi-cli", label: "安装/配置 Pi", hint: "CLI", group: "cli" },
-  { value: "codex-cli", label: "安装/配置 Codex", hint: "CLI", group: "cli" },
-  { value: "claude-cli", label: "安装/配置 Claude Code", hint: "CLI", group: "cli" },
+  { value: "pi-cli", label: "配置/安装 Pi", hint: "CLI", group: "cli" },
+  { value: "codex-cli", label: "配置/安装 Codex", hint: "CLI", group: "cli" },
+  { value: "claude-cli", label: "配置/安装 Claude Code", hint: "CLI", group: "cli" },
   { value: "exit", label: "退出", group: "exit" }
 ];
 const interactiveMenuDefaultValue = "full-init";
 const cliToolMenuDescriptorMap = {
   pi: [
-    { value: "pi-install", label: "安装/更新 Pi" },
     { value: "pi-api", label: "配置 Pi API" },
+    { value: "pi-install", label: "安装/更新 Pi" },
     { value: "back", label: "返回上一级" }
   ],
   codex: [
-    { value: "codex-install", label: "安装/更新 Codex" },
     { value: "codex-api", label: "配置 Codex API" },
+    { value: "codex-install", label: "安装/更新 Codex" },
     { value: "back", label: "返回上一级" }
   ],
   claude: [
-    { value: "claude-install", label: "安装/更新 Claude Code" },
     { value: "claude-api", label: "配置 Claude Code API" },
+    { value: "claude-install", label: "安装/更新 Claude Code" },
     { value: "back", label: "返回上一级" }
   ]
 };
-const augmentContextEngineFeaturePrompt = {
-  message: "是否启用 augment-context-engine MCP 代码检索支持？不确定建议选否，可减少 MCP 安装和配置麻烦。",
-  initialValue: false
-};
-
 class CancelledError extends Error {
   constructor(message = "用户取消") {
     super(message);
@@ -72,6 +66,15 @@ function resolvePasswordValue(userInput, existingValue) {
   return existingValue || undefined;
 }
 
+function passwordPromptOptions(message, existingValue, validate) {
+  const configured = typeof existingValue === "string" && existingValue.trim() !== "";
+  return {
+    message: `${message}${configured ? "（已配置，直接回车保留；输入 - 清除）" : "（输入 - 清除）"}`,
+    mask: "*",
+    ...(validate ? { validate } : {})
+  };
+}
+
 function assertNotCancelled(value) {
   if (p.isCancel(value)) throw new CancelledError();
 }
@@ -88,30 +91,14 @@ async function selectOrCancel(options) {
   return value;
 }
 
-function getAugmentContextEnginePromptOptions() {
-  return { ...augmentContextEngineFeaturePrompt };
-}
-
-function getClaudePermissionProfilePromptOptions(initialValue = "standard") {
-  return {
-    message: "请选择 Claude Code 权限配置档",
-    options: [
-      { value: "standard", label: "standard（默认，不预授权 Bash/Write/Edit）" },
-      { value: "trusted", label: "trusted（显式授予完整工具权限）" }
-    ],
-    initialValue: initialValue === "trusted" ? "trusted" : "standard"
-  };
-}
-
 export {
   assertNotCancelled,
   buildCliToolMenuDescriptors,
   CancelledError,
   confirmOrCancel,
-  getClaudePermissionProfilePromptOptions,
-  getAugmentContextEnginePromptOptions,
   interactiveMenuDefaultValue,
   interactiveMenuDescriptors,
+  passwordPromptOptions,
   required,
   requiredUnlessExisting,
   resolvePasswordValue,

package/lib/installer/assets.mjs

@@ -8,7 +8,6 @@ import {
   readJsonFileSafe,
   writeText
 } from "../config/store.mjs";
-import { renderWorkflowTemplate } from "./render.mjs";
 import { createInstallReport, readInstallMetadata } from "./state.mjs";
 
 const ignoredSkillPathPatterns = [
@@ -81,7 +80,7 @@ function shouldCopySkillPath(skillsRoot, sourcePath) {
   return !ignoredSkillPathPatterns.some((pattern) => pattern.test(relativePath));
 }
 
-async function collectFiles(root, outputPrefix, { filter, mapTargetPath, render } = {}) {
+async function collectFiles(root, outputPrefix, { filter, mapTargetPath } = {}) {
   const assets = new Map();
   async function visit(directory) {
     const entries = await fs.readdir(directory, { withFileTypes: true });
@@ -97,17 +96,14 @@ async function collectFiles(root, outputPrefix, { filter, mapTargetPath, render
       const sourceRelativePath = normalizeRelativePath(relative(root, sourcePath));
       if (sourceRelativePath.endsWith(".skill-lock.json")) continue;
       const sourceContent = await fs.readFile(sourcePath);
-      const renderedContent = render
-        ? Buffer.from(render(sourceContent.toString("utf8"), sourceRelativePath))
-        : sourceContent;
       const sourceStat = await fs.stat(sourcePath);
       const targetRelativePath = normalizeRelativePath(join(
         outputPrefix,
         mapTargetPath ? mapTargetPath(sourceRelativePath) : sourceRelativePath
       ));
       assets.set(targetRelativePath, {
-        content: renderedContent,
-        hash: hashBytes(renderedContent),
+        content: sourceContent,
+        hash: hashBytes(sourceContent),
         sourceHash: hashBytes(sourceContent),
         mode: sourceStat.mode & 0o777,
         sourcePath
@@ -126,12 +122,11 @@ async function addAssetTree(manifest, root, outputPrefix, options = {}) {
   for (const [key, value] of await collectFiles(root, outputPrefix, options)) manifest.set(key, value);
 }
 
-async function collectManagedAssets(paths, featureState) {
+async function collectManagedAssets(paths) {
   const manifest = new Map();
   await addAssetTree(manifest, paths.workflowTemplateRoot, "", {
     required: true,
-    mapTargetPath: mapGitignoreTemplate,
-    render: (content) => renderWorkflowTemplate(content, featureState)
+    mapTargetPath: mapGitignoreTemplate
   });
 
   const readmePath = join(paths.packageRoot, "README.md");
@@ -258,16 +253,17 @@ async function readPackageVersion(paths) {
 
 async function syncManagedFiles({
   paths,
-  featureState = {},
-  force = false
+  force = false,
+  pathPrefix = null
 }) {
   const previousMetadata = await readInstallMetadata(paths);
   const previousManagedFiles = await readManagedFiles(paths, previousMetadata);
-  const manifest = await collectManagedAssets(paths, featureState);
+  const manifest = await collectManagedAssets(paths);
   const report = createInstallReport();
-  const managedFiles = {};
+  const managedFiles = pathPrefix ? { ...previousManagedFiles } : {};
 
   for (const [relativePath, asset] of manifest) {
+    if (pathPrefix && !relativePath.startsWith(pathPrefix)) continue;
     const managedHash = await applyManifestEntry(
       paths,
       relativePath,
@@ -277,18 +273,20 @@ async function syncManagedFiles({
       report
     );
     if (managedHash) managedFiles[relativePath] = managedHash;
+    else delete managedFiles[relativePath];
   }
   for (const [relativePath, previousHash] of Object.entries(previousManagedFiles)) {
+    if (pathPrefix && !relativePath.startsWith(pathPrefix)) continue;
     if (!manifest.has(relativePath)) {
       const managedHash = await removeStaleManagedFile(paths, relativePath, previousHash, force, report);
       if (managedHash) managedFiles[relativePath] = managedHash;
+      else delete managedFiles[relativePath];
     }
   }
 
   return {
     previousMetadata,
     packageVersion: await readPackageVersion(paths),
-    features: featureState,
     managedFiles,
     report
   };

package/lib/installer/install.mjs

@@ -1,13 +1,8 @@
 import { join } from "node:path";
 import { pathExists, readJsonFileSafe } from "../config/store.mjs";
 import { createPaths, defaultPaths } from "../paths.mjs";
-import {
-  ensureClaudeSettingsForFeature,
-  getPreviousManagedClaudePermissions
-} from "../providers/claude.mjs";
 import { readManagedFiles, syncManagedFiles } from "./assets.mjs";
 import { linkClaude, linkCodex, linkPi } from "./links.mjs";
-import { resolveAugmentContextEngineFeature } from "./render.mjs";
 import {
   buildInstallMetadata,
   createInstallReport,
@@ -41,18 +36,6 @@ function resolveInstallPaths(options = {}) {
   });
 }
 
-function resolveFeatureState(options, previousMetadata) {
-  const overrides = {
-    ...(options.featureOverrides ?? {})
-  };
-  return {
-    ...(previousMetadata.features && typeof previousMetadata.features === "object"
-      ? previousMetadata.features
-      : {}),
-    augmentContextEngine: resolveAugmentContextEngineFeature(overrides, previousMetadata)
-  };
-}
-
 function reportFromLinkResults(results) {
   const report = createInstallReport();
   for (const result of results) {
@@ -86,7 +69,6 @@ async function packageVersionFor(paths, previousMetadata) {
 async function installWorkflow(options) {
   const paths = validatedPaths(options.paths);
   const previousMetadata = await readInstallMetadata(paths);
-  const featureState = resolveFeatureState(options, previousMetadata);
   let assetResult;
 
   if (options.relinkOnly) {
@@ -96,14 +78,12 @@ async function installWorkflow(options) {
     assetResult = {
       previousMetadata,
       packageVersion: await packageVersionFor(paths, previousMetadata),
-      features: featureState,
       managedFiles: await readManagedFiles(paths, previousMetadata),
       report: createInstallReport()
     };
   } else {
     assetResult = await syncManagedFiles({
       paths,
-      featureState,
       force: options.force ?? false
     });
   }
@@ -114,16 +94,12 @@ async function installWorkflow(options) {
   const codexResults = await linkCodex(paths, previousLinkedTargets, linkOptions);
   const piResults = await linkPi(paths, previousLinkedTargets, linkOptions);
   const linkResults = [...claudeResults, ...codexResults, ...piResults];
-  const ensureClaudeSettings = options.ensureClaudeSettings ?? ensureClaudeSettingsForFeature;
-  const managedClaudePermissions = await ensureClaudeSettings(paths, featureState.augmentContextEngine, previousMetadata);
   const linkedTargets = mergeLinkedTargets(previousLinkedTargets, linkResults);
 
   const metadata = buildInstallMetadata({
     previousMetadata,
     packageVersion: assetResult.packageVersion,
-    features: featureState,
     managedFiles: assetResult.managedFiles,
-    managedClaudePermissions,
     linkedTargets
   });
   await writeInstallMetadata(paths, metadata);
@@ -134,33 +110,43 @@ async function installManagedWorkflow(options = {}) {
   return installWorkflow({ ...options, paths: resolveInstallPaths(options) });
 }
 
-async function ensureWorkflowPresent(inputPaths) {
+async function ensureSkillPresent(inputPaths, skillName) {
   const paths = validatedPaths(inputPaths);
-  return installWorkflow({ paths, force: false, relinkOnly: false });
+  const previousMetadata = await readInstallMetadata(paths);
+  const assetResult = await syncManagedFiles({
+    paths,
+    force: false,
+    pathPrefix: `skills/${skillName}/`
+  });
+  const metadata = buildInstallMetadata({
+    previousMetadata,
+    packageVersion: assetResult.packageVersion,
+    managedFiles: assetResult.managedFiles,
+    linkedTargets: previousMetadata.linkedTargets ?? {}
+  });
+  await writeInstallMetadata(paths, metadata);
+  return assetResult.report;
 }
 
 async function ensurePiResourcesLinked(inputPaths) {
   const paths = validatedPaths(inputPaths);
   const previousMetadata = await readInstallMetadata(paths);
-  const featureState = resolveFeatureState({}, previousMetadata);
-  const assetResult = await syncManagedFiles({ paths, featureState, force: false });
+  const assetResult = await syncManagedFiles({ paths, force: false });
   const previousLinkedTargets = previousMetadata.linkedTargets ?? {};
   const piResults = await linkPi(paths, previousLinkedTargets, { force: false });
   const metadata = buildInstallMetadata({
     previousMetadata,
     packageVersion: assetResult.packageVersion,
-    features: featureState,
     managedFiles: assetResult.managedFiles,
-    managedClaudePermissions: getPreviousManagedClaudePermissions(previousMetadata),
     linkedTargets: mergeLinkedTargets(previousLinkedTargets, piResults)
   });
   await writeInstallMetadata(paths, metadata);
-  return piResults;
+  return mergeInstallReports(assetResult.report, reportFromLinkResults(piResults));
 }
 
 export {
   ensurePiResourcesLinked,
-  ensureWorkflowPresent,
+  ensureSkillPresent,
   installManagedWorkflow,
   installWorkflow,
   packageVersionFor

package/lib/installer/state.mjs

@@ -43,12 +43,6 @@ function getPreviousManagedCodexAgentFiles(previousMetadata = {}) {
   return normalizeManagedCodexAgentFiles(previousMetadata.managedCodexAgentFiles);
 }
 
-function getPreviousClaudePermissionProfile(previousMetadata = {}) {
-  return isMetadataV2(previousMetadata) && previousMetadata.claudePermissionProfile === "trusted"
-    ? "trusted"
-    : "standard";
-}
-
 async function readInstallMetadata(paths) {
   const metadata = await readJsonFileSafe(metadataPathFor(paths), {});
   if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
@@ -64,23 +58,17 @@ async function writeInstallMetadata(paths, metadata) {
 function buildInstallMetadata({
   previousMetadata = {},
   packageVersion,
-  features = {},
   managedFiles = {},
-  managedClaudePermissions = [],
   managedCodexAuthKeys = getPreviousManagedCodexAuthKeys(previousMetadata),
   managedCodexAgentFiles = getPreviousManagedCodexAgentFiles(previousMetadata),
-  claudePermissionProfile = getPreviousClaudePermissionProfile(previousMetadata),
   linkedTargets = {}
 }) {
   const metadata = {
     schemaVersion: 2,
     packageVersion,
-    features: sortObject(features),
     managedFiles: sortObject(managedFiles),
-    managedClaudePermissions: [...new Set(managedClaudePermissions)].sort(),
     managedCodexAuthKeys: [...new Set(managedCodexAuthKeys)].sort(),
     managedCodexAgentFiles: normalizeManagedCodexAgentFiles(managedCodexAgentFiles),
-    claudePermissionProfile,
     linkedTargets: sortObject(linkedTargets)
   };
   if (typeof previousMetadata.installedAt === "string") {
@@ -102,18 +90,12 @@ function finalizeProviderInstallMetadata({
       && previousMetadata.packageVersion
       ? previousMetadata.packageVersion
       : packageVersion,
-    features: objectField(previousMetadata.features),
     managedFiles: isV2 ? objectField(previousMetadata.managedFiles) : {},
-    managedClaudePermissions: stringArray(
-      overrides.managedClaudePermissions ?? previousMetadata.managedClaudePermissions
-    ),
     managedCodexAuthKeys: stringArray(
       overrides.managedCodexAuthKeys ?? getPreviousManagedCodexAuthKeys(previousMetadata)
     ),
     managedCodexAgentFiles: overrides.managedCodexAgentFiles
       ?? getPreviousManagedCodexAgentFiles(previousMetadata),
-    claudePermissionProfile: overrides.claudePermissionProfile
-      ?? getPreviousClaudePermissionProfile(previousMetadata),
     linkedTargets: objectField(previousMetadata.linkedTargets)
   });
 }
@@ -170,7 +152,6 @@ export {
   buildInstallMetadata,
   createInstallReport,
   finalizeProviderInstallMetadata,
-  getPreviousClaudePermissionProfile,
   getPreviousManagedCodexAgentFiles,
   getPreviousManagedCodexAuthKeys,
   linkedTargetsFromResults,