abelworkflow 1.2.3 → 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

@@ -8,6 +8,20 @@ const RESPONSES_PROVIDERS = new Set(["abelworkflow", "gpt"]);
 const UNSUPPORTED_SPARK_REASONING_EFFORTS = new Set(["none", "minimal"]);
 const TRANSIENT_UPSTREAM_ERROR = /\bupstream(?:[_ -]error|\s+request\s+failed)\b/i;
 const EXPLICIT_ERROR_STATUS = /(?:^\s*|\b(?:upstream(?:[_ -]error|\s+request\s+failed)|code|error(?:[_ -]?code)?|http(?:\/\d+(?:\.\d+)*)?(?:[_ -]?status(?:[_ -]?code)?)?|status(?:[_ -]?code)?)\b\s*["']?\s*[:=(]?\s*)["']?([45]\d{2})["']?(?!\d)/i;
+const SUMMARIZATION_SYSTEM_PROMPT = "You summarize coding conversations into concise continuation checkpoints. Output only the requested structured summary.";
+const SUMMARIZATION_PROMPT = `Create a structured checkpoint using exactly these sections:
+
+## Goal
+## Constraints & Preferences
+## Progress
+### Done
+### In Progress
+### Blocked
+## Key Decisions
+## Next Steps
+## Critical Context
+
+Preserve exact file paths, function names, decisions, errors, and unfinished work. Be concise but include everything needed to continue.`;
 
 function isRecord(value: unknown): value is JsonRecord {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -98,9 +112,13 @@ function normalizeInputItem(item: unknown): unknown {
   if (item.type === "reasoning") return undefined;
 
   if (item.type === "message") {
-    const content = normalizeAssistantContent(item.content);
+    const role = item.role === "user" ? "user" : item.role === "assistant" ? "assistant" : undefined;
+    if (!role) return undefined;
+    const content = role === "user"
+      ? normalizeUserContent(item.content)
+      : normalizeAssistantContent(item.content);
     if (Array.isArray(content) && content.length === 0) return undefined;
-    return { role: "assistant", content };
+    return { role, content };
   }
 
   if (item.role === "user") {
@@ -157,32 +175,153 @@ function normalizeReasoning(payload: JsonRecord, modelId: string | undefined): v
   payload.reasoning = { ...payload.reasoning, effort: "low" };
 }
 
+function serializeConversation(messages: unknown[]): string {
+  return messages.map((message) => {
+    if (!isRecord(message)) return "";
+    const content = textFromContent(message.content) ?? "";
+    if (message.role === "user") return content ? `[User]: ${content}` : "";
+    if (message.role === "toolResult") {
+      const text = content.length > 2000 ? `${content.slice(0, 2000)}\n[truncated]` : content;
+      return text ? `[Tool result]: ${text}` : "";
+    }
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      const parts: string[] = [];
+      const thinking = message.content
+        .filter((part) => isRecord(part) && part.type === "thinking" && typeof part.thinking === "string")
+        .map((part) => part.thinking)
+        .join("\n");
+      if (thinking) parts.push(`[Assistant thinking]: ${thinking}`);
+      if (content) parts.push(`[Assistant]: ${content}`);
+      const calls = message.content
+        .filter((part) => isRecord(part) && part.type === "toolCall")
+        .map((part) => `${part.name}(${JSON.stringify(part.arguments ?? {})})`)
+        .join("; ");
+      if (calls) parts.push(`[Assistant tool calls]: ${calls}`);
+      return parts.join("\n");
+    }
+    if (message.role === "bashExecution") {
+      return `[Bash]: ${String(message.command ?? "")}\n${String(message.output ?? "")}`;
+    }
+    if (typeof message.summary === "string") return `[Previous checkpoint]: ${message.summary}`;
+    return content;
+  }).filter(Boolean).join("\n\n");
+}
+
+function fileDetails(fileOps: unknown): {
+  readFiles: string[];
+  modifiedFiles: string[];
+} {
+  if (!isRecord(fileOps)) return { readFiles: [], modifiedFiles: [] };
+  const modified = new Set<string>([
+    ...(fileOps.edited instanceof Set ? fileOps.edited : []),
+    ...(fileOps.written instanceof Set ? fileOps.written : []),
+  ]);
+  return {
+    readFiles: [...(fileOps.read instanceof Set ? fileOps.read : [])]
+      .filter((path): path is string => typeof path === "string" && !modified.has(path))
+      .sort(),
+    modifiedFiles: [...modified].sort(),
+  };
+}
+
+function formatFileDetails(details: { readFiles: string[]; modifiedFiles: string[] }): string {
+  const sections: string[] = [];
+  if (details.readFiles.length > 0) {
+    sections.push(`<read-files>\n${details.readFiles.join("\n")}\n</read-files>`);
+  }
+  if (details.modifiedFiles.length > 0) {
+    sections.push(`<modified-files>\n${details.modifiedFiles.join("\n")}\n</modified-files>`);
+  }
+  return sections.length > 0 ? `\n\n${sections.join("\n\n")}` : "";
+}
+
+function normalizeResponsesPayload(
+  payload: unknown,
+  model: unknown,
+  systemPrompt: string,
+): JsonRecord | undefined {
+  if (!isRecord(payload) || !isCompatibleResponsesModel(model)) return undefined;
+
+  const input = normalizeInput(payload.input);
+  const first = Array.isArray(payload.input) ? payload.input.find(isRecord) : undefined;
+  const firstIsPrompt = first?.role === "system" || first?.role === "developer";
+  const instructions =
+    textFromContent(payload.instructions) ||
+    (firstIsPrompt ? textFromContent(first.content) : undefined) ||
+    systemPrompt.trim() ||
+    DEFAULT_INSTRUCTIONS;
+  const nextPayload: JsonRecord = { ...payload, instructions, input, store: false };
+
+  delete nextPayload.max_output_tokens;
+  delete nextPayload.prompt_cache_key;
+  delete nextPayload.prompt_cache_retention;
+  delete nextPayload.previous_response_id;
+
+  normalizeReasoning(nextPayload, isRecord(model) && typeof model.id === "string" ? model.id : undefined);
+  return nextPayload;
+}
+
 export default function (pi: ExtensionAPI) {
-  pi.on("before_provider_request", (event, ctx) => {
-    const payload = event.payload as unknown;
-    if (!isRecord(payload)) return;
-    if (!isCompatibleResponsesModel(ctx.model)) return;
-
-    const input = normalizeInput(payload.input);
-    const first = Array.isArray(payload.input) ? payload.input.find(isRecord) : undefined;
-    const firstIsPrompt = first?.role === "system" || first?.role === "developer";
-    const instructions =
-      textFromContent(payload.instructions) ||
-      (firstIsPrompt ? textFromContent(first.content) : undefined) ||
-      ctx.getSystemPrompt().trim() ||
-      DEFAULT_INSTRUCTIONS;
-
-    const nextPayload: JsonRecord = { ...payload, instructions, input, store: false };
-
-    // Unsupported or risky for this Codex passthrough endpoint.
-    delete nextPayload.max_output_tokens;
-    delete nextPayload.prompt_cache_key;
-    delete nextPayload.prompt_cache_retention;
-    delete nextPayload.previous_response_id;
-
-    normalizeReasoning(nextPayload, ctx.model?.id);
-
-    return nextPayload;
+  pi.on("before_provider_request", (event, ctx) =>
+    normalizeResponsesPayload(event.payload, ctx.model, ctx.getSystemPrompt()));
+
+  pi.on("session_before_compact", async (event, ctx) => {
+    const model = ctx.model;
+    if (!model || !isCompatibleResponsesModel(model)) return;
+
+    const { preparation } = event;
+    const conversation = serializeConversation([
+      ...preparation.messagesToSummarize,
+      ...preparation.turnPrefixMessages,
+    ]);
+    const prompt = [
+      `<conversation>\n${conversation}\n</conversation>`,
+      preparation.previousSummary
+        ? `<previous-summary>\n${preparation.previousSummary}\n</previous-summary>\nPreserve and update this previous checkpoint.`
+        : "",
+      preparation.isSplitTurn
+        ? "The conversation ends with the prefix of a split turn; its recent suffix remains in context."
+        : "",
+      SUMMARIZATION_PROMPT,
+      event.customInstructions ? `Additional focus: ${event.customInstructions}` : "",
+    ].filter(Boolean).join("\n\n");
+    const response = await ctx.modelRegistry.complete(
+      model,
+      {
+        systemPrompt: SUMMARIZATION_SYSTEM_PROMPT,
+        messages: [{
+          role: "user",
+          content: [{ type: "text", text: prompt }],
+          timestamp: Date.now(),
+        }],
+      },
+      {
+        signal: event.signal,
+        cacheRetention: "none",
+        ...(ctx.thinkingLevel && ctx.thinkingLevel !== "off"
+          ? { reasoningEffort: ctx.thinkingLevel }
+          : {}),
+        onPayload: (payload: unknown, payloadModel: unknown) =>
+          normalizeResponsesPayload(payload, payloadModel, SUMMARIZATION_SYSTEM_PROMPT),
+      },
+    );
+    if (response.stopReason === "error") {
+      throw new Error(`Summarization failed: ${response.errorMessage ?? "Unknown error"}`);
+    }
+    if (response.stopReason === "aborted") throw new Error("Compaction cancelled");
+
+    const summaryText = textFromContent(response.content);
+    if (!summaryText) throw new Error("Summarization failed: Empty response");
+    const details = fileDetails(preparation.fileOps);
+    return {
+      compaction: {
+        summary: `${summaryText}${formatFileDetails(details)}`,
+        firstKeptEntryId: preparation.firstKeptEntryId,
+        tokensBefore: preparation.tokensBefore,
+        usage: response.usage,
+        details,
+      },
+    };
   });
 
   pi.on("message_end", (event, ctx) => {

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: "返回上一级" }
   ];
 }