msdevflow 0.7.3 → 0.7.5

package/README.md

@@ -1,6 +1,6 @@
 # msdevflow
 
-`msdevflow` 是一个用于 GitCode 的 Agent Skill，可以把已授权的 Issue 安全推进到代码实现、普通 PR、CI、检视意见闭环和最终合入，也可以通过显式 `action` 只执行其中一个能力。正式支持 Claude Code、Codex 和 OpenCode；Trae 的 Skills 安装与兼容机制尚未完成可靠验证，因此当前不宣称支持。
+`msdevflow` npm 包提供一套 GitCode Agent Skills：`msd` 核心可以把已授权的 Issue 安全推进到代码实现、普通 PR、CI、检视意见闭环和最终合入，十个 `msd-<action>` 薄路由入口用于在输入阶段发现并运行单项能力。正式支持 Claude Code、Codex 和 OpenCode；Trae 的 Skills 安装与兼容机制尚未完成可靠验证，因此当前不宣称支持。
 
 ## 安装
 
@@ -29,11 +29,11 @@ npx msdevflow@latest setup
 
 `setup` 默认检测 PATH 中的 Claude Code、Codex 和 OpenCode，展示完整计划并在确认后：
 
-1. 把同一份 `msdevflow` skill 原子安装或更新到所需目标；
+1. 把一个 `msd` 核心和十个 `msd-<action>` 路由器作为整套事务原子安装或更新到所需目标；
 2. 安装或升级官方 `@gitcode-cli/cli@latest`；
 3. 安装受审的 Python Playwright 依赖；
 4. 验收 Issue、PR、结构化评论、行内评论、JSON、显式仓库和正文文件等 CLI 能力；
-5. GitCode CLI 未认证时打开官方浏览器登录。
+5. GitCode CLI 未认证时打开官方 Token 创建页面，并让 CLI 自己的终端提示接收 Token。
 
 显式选择客户端或只读预检：
 
@@ -47,15 +47,17 @@ npx msdevflow setup --dry-run --targets all
 安装目录映射：
 
 ```text
-Claude Code                 -> ~/.claude/skills/msdevflow
-Codex                       -> ~/.agents/skills/msdevflow
-仅 OpenCode                 -> ~/.agents/skills/msdevflow
-OpenCode + Claude Code      -> 复用 ~/.claude/skills/msdevflow
-OpenCode + Codex            -> 复用 ~/.agents/skills/msdevflow
-Claude Code + Codex         -> 两个受管副本
-三者同时安装                -> 两个受管副本，并提示 OpenCode 可从两处发现同名 skill
+Claude Code                 -> ~/.claude/skills/{msd,msd-*}
+Codex                       -> ~/.agents/skills/{msd,msd-*}
+仅 OpenCode                 -> ~/.agents/skills/{msd,msd-*}
+OpenCode + Claude Code      -> 复用 Claude 目标
+OpenCode + Codex            -> 复用 Agent Skills 目标
+Claude Code + Codex         -> 两套受管副本
+三者同时安装                -> 两套受管副本，并提示 OpenCode 双路径发现
 ```
 
+每个物理目标都包含完整套件，薄路由器不复制核心业务规则。已有 entry 只有在 manifest 精确匹配自身名称时才允许更新；由旧版包管理的 `msdevflow` 目录会在新套件全部验证后安全迁移，来源不明的目录、文件或符号链接会阻断安装。
+
 自定义目录：
 
 ```bash
@@ -65,25 +67,15 @@ npx msdevflow setup --agents-skills-dir "<shared-agent-skills-directory>"
 
 `--skills-dir` 未配合 `--targets` 使用时保留旧语义，只安装 Claude Code 目标。没有检测到客户端时，交互运行会要求选择目标；非交互运行必须提供 `--targets`。安装完成后重启或重新加载对应客户端。如果机器已有 Python 版本的 `gitcode`，setup 会保留它，并为 npm CLI 创建 `gitcode-npm` 命令；否则使用 `gitcode`。
 
-## 完整端到端流程
+## 运行与 action 补全
 
-从目标仓库目录启动已安装目标中的任一客户端，然后调用 skill：
+从目标仓库目录启动客户端。直接调用核心 `msd` 会运行完整作者 E2E：
 
-- Claude Code：输入 `/msdevflow`；
-- Codex：使用 `$msdevflow`、`/skills` 选择，或让 Codex 按描述隐式匹配；
-- OpenCode：通过其 skill 工具选择，或让 OpenCode 按描述隐式匹配。
+- Claude Code：输入并提交 `/msd`；
+- Codex：使用 `$msd` 或从 `/skills` 选择；
+- OpenCode：打开 `/skills`，选择 `msd`，再提交插入的 `/msd`。`@` 用于文件、reference 或 agent，不用于选择 Skill。
 
-客户端 UI 和命令入口可能随版本变化，但传给 skill 的任务正文相同：
-
-```text
-处理 https://gitcode.com/<canonical-owner>/<repo>/issues/<number>。
-本地仓库：<local-repository-absolute-path>
-canonical：<canonical-owner>/<repo>
-source：<your-account>/<repo>
-使用 guided 模式，按权威远端和本地证据推进完整作者 E2E。
-```
-
-未指定 `action` 时，流程为：
+核心流程为：
 
 ```text
 Issue 发现/核验
@@ -98,10 +90,11 @@ Issue 发现/核验
 -> 远端回读 PR 已 merged
 ```
 
-这是可暂停、可恢复的流程。外部检视或审批有新进展后，可再次运行：
+调用正文可提供 Issue/PR URL、仓库路径、canonical、source 和模式。核心 `msd` 不显示运行时 Question 菜单。
+
+这是可暂停、可恢复的流程。外部检视或审批有新进展后，可再次提交 `/msd` 和 PR 信息：
 
 ```text
-/msdevflow
 恢复 https://gitcode.com/<canonical-owner>/<repo>/pulls/<number> 的完整作者 E2E。
 本地仓库：<local-repository-absolute-path>
 canonical：<canonical-owner>/<repo>
@@ -111,7 +104,7 @@ source：<your-account>/<repo>
 
 ## 独立 action
 
-显式提供 `action=<name>` 时，只运行该 action，完成后立即停止；前置条件不足时不会隐式补跑上游流程。
+Claude Code/OpenCode 输入 `/msd-`、Codex 输入 `$msd-` 即可筛选十个独立入口。每个入口只运行对应 action，完成后立即停止；前置条件不足时不会隐式补跑上游流程。`/msd action=<name>` 和 `$msd action=<name>` 仍是兼容调用，但参数本身不提供跨客户端枚举补全。
 
 | action | 用途 | 完成状态或结果 |
 |---|---|---|
@@ -129,19 +122,19 @@ source：<your-account>/<repo>
 示例：
 
 ```text
-/msdevflow action=create-issue
+/msd-create-issue
 在 Ascend/example 提一个 bug：升级后首次启动失败……
 使用 guided 模式，确认完整预览后再创建。
 ```
 
 ```text
-/msdevflow action=ci
+/msd-ci
 PR：https://gitcode.com/Ascend/example/pulls/456
 本地仓库：D:\work\example
 ```
 
 ```text
-/msdevflow action=code-review
+/msd-code-review
 PR：https://gitcode.com/Ascend/example/pulls/789
 ```
 
@@ -172,7 +165,7 @@ Agent 写入的 PR/Issue 正文、评论和 discussion 回复末尾会附加：
 `msdevflow`：
 
 - 不读取、打印或转存 GitCode Token；
-- 不要求用户把 Token 粘贴到终端、对话或项目文件；
+- Token 只粘贴到 GitCode CLI 自己的终端提示，不放入 Agent 对话、命令参数、项目文件、URL 或日志；
 - openLiBing Token 只在当前 Python 认证进程内短暂使用，不输出、不落盘；
 - 永远不会自动下载 Playwright Chromium；
 - 优先使用系统 Chrome/Edge，其次使用已经安装的 Playwright Chromium；
@@ -183,17 +176,19 @@ Agent 写入的 PR/Issue 正文、评论和 discussion 回复末尾会附加：
 
 ## 常见阻塞
 
-### 客户端找不到 `msdevflow`
+### 客户端找不到 `msd` 或 `msd-<action>`
 
-按目标确认至少一个受支持的 manifest 存在，然后重启或重新加载客户端：
+按目标确认核心和相应路由器的 manifest 都存在，然后重启或重新加载客户端：
 
 ```text
-Claude Code: ~/.claude/skills/msdevflow/SKILL.md
-Codex:       ~/.agents/skills/msdevflow/SKILL.md
+Claude Code: ~/.claude/skills/msd/SKILL.md
+             ~/.claude/skills/msd-<action>/SKILL.md
+Codex:       ~/.agents/skills/msd/SKILL.md
+             ~/.agents/skills/msd-<action>/SKILL.md
 OpenCode:    上述任一路径（按 setup 计划）
 ```
 
-可运行 `npx msdevflow setup --dry-run --targets <clients>` 检查目标映射。
+Claude Code/OpenCode 可输入 `/msd-` 筛选 action；Codex 使用 `$msd-`。可运行 `npx msdevflow setup --dry-run --targets <clients>` 检查目标映射。
 
 ### `blocked: bootstrap-required`
 
@@ -212,7 +207,7 @@ npx msdevflow setup
 <gitcode-command> auth status --json
 ```
 
-用户只在官方浏览器页面输入凭证。
+用户在官方页面创建 Token，并只粘贴到 GitCode CLI 自己的终端提示；不要把 Token 交给 Agent 或放入命令参数、项目文件、URL 或日志。
 
 ### `blocked: browser-required`
 
@@ -224,4 +219,4 @@ npx msdevflow setup
 
 ## 详细文档
 
-完整 action、恢复、模板、CI、review、UTF-8 和安全契约见 [`skill/msdevflow/README.md`](skill/msdevflow/README.md)。
+完整 action、恢复、模板、CI、review、UTF-8 和安全契约见 [`skill/msd/README.md`](skill/msd/README.md)。

package/lib/bootstrap.js

@@ -24,7 +24,25 @@ import { fileURLToPath } from "node:url";
 const REGISTRY = "https://registry.npmjs.org";
 const GITCODE_PACKAGE = "@gitcode-cli/cli@latest";
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const BUNDLED_SKILL_DIR = path.join(PACKAGE_ROOT, "skill", "msdevflow");
+const BUNDLED_SKILLS_DIR = path.join(PACKAGE_ROOT, "skill");
+const CORE_SKILL_NAME = "msd";
+const LEGACY_SKILL_NAME = "msdevflow";
+export const ACTIONS = [
+  "discover",
+  "create-issue",
+  "issue",
+  "develop",
+  "pr",
+  "ci",
+  "openlibing-auth",
+  "feedback",
+  "code-review",
+  "merge",
+];
+export const MANAGED_SKILL_NAMES = [
+  CORE_SKILL_NAME,
+  ...ACTIONS.map((action) => `${CORE_SKILL_NAME}-${action}`),
+];
 const SUPPORTED_CLIENTS = ["claude", "codex", "opencode"];
 const REQUIRED_SCHEMAS = {
   "auth login": ["web"],
@@ -70,8 +88,8 @@ client is detected, interactive setup asks which clients to install; non-interac
 setup requires --targets. OpenCode reuses a Claude or shared Agent Skills target
 instead of creating a third copy.
 
-The setup installs or updates the bundled msdevflow skill, installs or upgrades
-the official GitCode npm CLI, and installs all reviewed Python runtime
+The setup installs or updates the bundled msd core and msd-<action> skills,
+installs or upgrades the official GitCode npm CLI, and installs all reviewed Python runtime
 dependencies. It never downloads or launches Chromium. If GitCode is not
 authenticated, it starts the CLI's official browser login; setup never reads or
 prints a token.`;
@@ -167,29 +185,33 @@ function defaultAgentsSkillsDir(options, environment, platform) {
     || path.join(environmentHome(environment, platform), ".agents", "skills");
 }
 
-function createSkillLayout(kind, clients, skillsDir, bundledSkillDir) {
+function createSkillLayout(kind, clients, skillsDir, bundledSkillsDir) {
   const resolvedSkillsDir = path.resolve(skillsDir);
-  const workflowDir = path.join(resolvedSkillsDir, "msdevflow");
-  const bundledWorkflowDir = path.resolve(bundledSkillDir);
+  const resolvedBundledSkillsDir = path.resolve(bundledSkillsDir);
+  const coreDir = path.join(resolvedSkillsDir, CORE_SKILL_NAME);
+  const bundledCoreDir = path.join(resolvedBundledSkillsDir, CORE_SKILL_NAME);
   return {
     kind,
     clients,
     skillsDir: resolvedSkillsDir,
-    workflowDir,
-    workflowManifest: path.join(workflowDir, "SKILL.md"),
-    pythonRequirements: path.join(workflowDir, "scripts", "requirements.txt"),
-    bundledSkillDir: bundledWorkflowDir,
-    bundledManifest: path.join(bundledWorkflowDir, "SKILL.md"),
-    bundledPythonRequirements: path.join(bundledWorkflowDir, "scripts", "requirements.txt"),
+    coreDir,
+    coreManifest: path.join(coreDir, "SKILL.md"),
+    pythonRequirements: path.join(coreDir, "scripts", "requirements.txt"),
+    legacyDir: path.join(resolvedSkillsDir, LEGACY_SKILL_NAME),
+    legacyManifest: path.join(resolvedSkillsDir, LEGACY_SKILL_NAME, "SKILL.md"),
+    bundledSkillsDir: resolvedBundledSkillsDir,
+    bundledCoreDir,
+    bundledCoreManifest: path.join(bundledCoreDir, "SKILL.md"),
+    bundledPythonRequirements: path.join(bundledCoreDir, "scripts", "requirements.txt"),
   };
 }
 
-export function resolveLayout(options, environment = process.env, bundledSkillDir = BUNDLED_SKILL_DIR) {
+export function resolveLayout(options, environment = process.env, bundledSkillsDir = BUNDLED_SKILLS_DIR) {
   return createSkillLayout(
     "claude",
     ["claude"],
     defaultClaudeSkillsDir(options, environment, process.platform),
-    bundledSkillDir,
+    bundledSkillsDir,
   );
 }
 
@@ -197,7 +219,7 @@ export function resolveLayouts(
   options,
   clients,
   environment = process.env,
-  bundledSkillDir = BUNDLED_SKILL_DIR,
+  bundledSkillsDir = BUNDLED_SKILLS_DIR,
   platform = process.platform,
 ) {
   const layouts = [];
@@ -207,7 +229,7 @@ export function resolveLayouts(
       "claude",
       openCodeUsesClaude ? ["claude", "opencode"] : ["claude"],
       defaultClaudeSkillsDir(options, environment, platform),
-      bundledSkillDir,
+      bundledSkillsDir,
     ));
   }
   if (clients.includes("codex") || (clients.includes("opencode") && !openCodeUsesClaude)) {
@@ -219,12 +241,12 @@ export function resolveLayouts(
       "agents",
       sharedClients,
       defaultAgentsSkillsDir(options, environment, platform),
-      bundledSkillDir,
+      bundledSkillsDir,
     ));
   }
   const unique = new Map();
   for (const layout of layouts) {
-    const key = normalizedPath(layout.workflowDir, platform);
+    const key = normalizedPath(layout.skillsDir, platform);
     const existing = unique.get(key);
     if (existing) {
       existing.clients = [...new Set([...existing.clients, ...layout.clients])];
@@ -440,7 +462,7 @@ function requireFile(file, description) {
   verifyFile(file, `${description} not found: ${file}. Reinstall the msdevflow npm package.`);
 }
 
-function skillManifestIsOwned(file) {
+function skillManifestIsOwned(file, expectedName) {
   try {
     const metadata = lstatSync(file);
     if (metadata.isSymbolicLink() || !metadata.isFile()) {
@@ -451,7 +473,7 @@ function skillManifestIsOwned(file) {
       return false;
     }
     const names = [...frontmatter[1].matchAll(/^name:\s*([^\s#]+)\s*$/gm)];
-    return names.length === 1 && names[0][1] === "msdevflow";
+    return names.length === 1 && names[0][1] === expectedName;
   } catch (error) {
     if (error?.code === "ENOENT") {
       return false;
@@ -491,26 +513,25 @@ function skillDigest(root) {
   return digest.digest("hex");
 }
 
-function skillInstallDetails(layout) {
-  requireFile(layout.bundledManifest, "bundled msdevflow skill manifest");
-  requireFile(layout.bundledPythonRequirements, "bundled workflow Python requirements file");
-  if (!skillManifestIsOwned(layout.bundledManifest)) {
-    throw new BootstrapError("Bundled skill manifest does not identify msdevflow.", 3);
+function installedSkillDetails(source, target, name) {
+  const sourceManifest = path.join(source, "SKILL.md");
+  requireFile(sourceManifest, `bundled ${name} skill manifest`);
+  if (!skillManifestIsOwned(sourceManifest, name)) {
+    throw new BootstrapError(`Bundled skill manifest does not identify ${name}.`, 3);
   }
-  validatePythonRequirements(layout.bundledPythonRequirements);
-  const bundledDigest = skillDigest(layout.bundledSkillDir);
+  const bundledDigest = skillDigest(source);
   let status = "absent";
   let existingDigest = null;
   try {
-    const metadata = lstatSync(layout.workflowDir);
+    const metadata = lstatSync(target);
     if (metadata.isSymbolicLink() || !metadata.isDirectory()
-        || !skillManifestIsOwned(layout.workflowManifest)) {
+        || !skillManifestIsOwned(path.join(target, "SKILL.md"), name)) {
       throw new BootstrapError(
-        `Refusing to overwrite a skills entry not owned by msdevflow: ${layout.workflowDir}`,
+        `Refusing to overwrite a skills entry not owned by ${name}: ${target}`,
         3,
       );
     }
-    existingDigest = skillDigest(layout.workflowDir);
+    existingDigest = skillDigest(target);
     status = existingDigest === bundledDigest ? "current" : "update";
   } catch (error) {
     if (error?.code !== "ENOENT") {
@@ -518,70 +539,211 @@ function skillInstallDetails(layout) {
     }
   }
   return {
-    source: layout.bundledSkillDir,
-    target: layout.workflowDir,
+    name,
+    source,
+    target,
     status,
     bundledDigest,
     existingDigest,
   };
 }
 
-function installBundledSkill(details) {
-  const parent = path.dirname(details.target);
-  mkdirSync(parent, { recursive: true });
-  const current = skillInstallDetails({
-    bundledSkillDir: details.source,
-    bundledManifest: path.join(details.source, "SKILL.md"),
-    bundledPythonRequirements: path.join(details.source, "scripts", "requirements.txt"),
-    workflowDir: details.target,
-    workflowManifest: path.join(details.target, "SKILL.md"),
-  });
-  if (current.status !== details.status || current.existingDigest !== details.existingDigest) {
-    throw new BootstrapError("msdevflow skill target changed after confirmation; refusing to overwrite it.", 3);
+function legacySkillDetails(layout) {
+  try {
+    const metadata = lstatSync(layout.legacyDir);
+    if (metadata.isSymbolicLink() || !metadata.isDirectory()
+        || !skillManifestIsOwned(layout.legacyManifest, LEGACY_SKILL_NAME)) {
+      throw new BootstrapError(
+        `Refusing to migrate a legacy skills entry not owned by ${LEGACY_SKILL_NAME}: ${layout.legacyDir}`,
+        3,
+      );
+    }
+    return {
+      target: layout.legacyDir,
+      status: "migrate",
+      existingDigest: skillDigest(layout.legacyDir),
+    };
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return {
+        target: layout.legacyDir,
+        status: "absent",
+        existingDigest: null,
+      };
+    }
+    throw error;
+  }
+}
+
+function skillInstallDetails(layout) {
+  requireFile(layout.bundledPythonRequirements, "bundled workflow Python requirements file");
+  validatePythonRequirements(layout.bundledPythonRequirements);
+  const entries = MANAGED_SKILL_NAMES.map((name) => installedSkillDetails(
+    path.join(layout.bundledSkillsDir, name),
+    path.join(layout.skillsDir, name),
+    name,
+  ));
+  return {
+    source: layout.bundledSkillsDir,
+    target: layout.skillsDir,
+    entries,
+    legacy: legacySkillDetails(layout),
+  };
+}
+
+function assertSkillInstallUnchanged(details) {
+  const layout = {
+    skillsDir: details.target,
+    bundledSkillsDir: details.source,
+    bundledPythonRequirements: path.join(
+      details.source,
+      CORE_SKILL_NAME,
+      "scripts",
+      "requirements.txt",
+    ),
+    legacyDir: path.join(details.target, LEGACY_SKILL_NAME),
+    legacyManifest: path.join(details.target, LEGACY_SKILL_NAME, "SKILL.md"),
+  };
+  const current = skillInstallDetails(layout);
+  for (let index = 0; index < details.entries.length; index += 1) {
+    const expected = details.entries[index];
+    const actual = current.entries[index];
+    if (actual.name !== expected.name || actual.status !== expected.status
+        || actual.existingDigest !== expected.existingDigest
+        || actual.bundledDigest !== expected.bundledDigest) {
+      throw new BootstrapError(
+        `Skill target changed after confirmation; refusing to overwrite it: ${expected.target}`,
+        3,
+      );
+    }
   }
-  if (current.status === "current") {
-    return "current";
+  if (current.legacy.status !== details.legacy.status
+      || current.legacy.existingDigest !== details.legacy.existingDigest) {
+    throw new BootstrapError(
+      `Legacy skill target changed after confirmation; refusing to migrate it: ${details.legacy.target}`,
+      3,
+    );
   }
-  const staging = path.join(parent, `.msdevflow-${randomUUID()}.tmp`);
-  const backup = path.join(parent, `.msdevflow-${randomUUID()}.backup`);
-  let movedExisting = false;
+}
+
+function installedSuiteResult(details) {
+  const entries = details.entries.map((entry) => ({
+    name: entry.name,
+    status: entry.status === "current"
+      ? "current"
+      : entry.status === "absent" ? "installed" : "updated",
+    target: entry.target,
+  }));
+  let status = "current";
+  if (details.legacy.status === "migrate") {
+    status = "migrated";
+  } else if (entries.some((entry) => entry.status === "updated")) {
+    status = "updated";
+  } else if (entries.some((entry) => entry.status === "installed")) {
+    status = "installed";
+  }
+  return { status, entries, legacy: details.legacy.status };
+}
+
+function suiteTransactionPath(details, name, extension) {
+  const skillsRootName = path.basename(details.target) || "skills";
+  return path.join(
+    path.dirname(details.target),
+    `.${skillsRootName}-msdevflow-${name}-${randomUUID()}.${extension}`,
+  );
+}
+
+function installBundledSkillSuites(suites) {
+  for (const details of suites) {
+    mkdirSync(details.target, { recursive: true });
+    assertSkillInstallUnchanged(details);
+  }
+  const staged = [];
+  const switched = [];
+  const migrated = [];
   try {
-    cpSync(details.source, staging, { recursive: true, errorOnExist: true });
-    if (skillDigest(staging) !== details.bundledDigest) {
-      throw new BootstrapError("Bundled skill verification failed after staging.", 3);
+    for (const details of suites) {
+      for (const entry of details.entries.filter((item) => item.status !== "current")) {
+        const staging = suiteTransactionPath(details, entry.name, "tmp");
+        cpSync(entry.source, staging, { recursive: true, errorOnExist: true });
+        if (skillDigest(staging) !== entry.bundledDigest) {
+          throw new BootstrapError(`Bundled ${entry.name} verification failed after staging.`, 3);
+        }
+        staged.push({ details, entry, staging });
+      }
     }
-    if (current.status === "update") {
-      renameSync(details.target, backup);
-      movedExisting = true;
+    for (const details of suites) {
+      assertSkillInstallUnchanged(details);
     }
-    try {
-      renameSync(staging, details.target);
-    } catch (error) {
-      if (movedExisting) {
-        renameSync(backup, details.target);
-        movedExisting = false;
+    for (const item of staged) {
+      const backup = suiteTransactionPath(item.details, item.entry.name, "backup");
+      if (item.entry.status === "update") {
+        renameSync(item.entry.target, backup);
       }
-      throw error;
+      try {
+        renameSync(item.staging, item.entry.target);
+      } catch (error) {
+        if (item.entry.status === "update") {
+          renameSync(backup, item.entry.target);
+        }
+        throw error;
+      }
+      switched.push({ ...item, backup: item.entry.status === "update" ? backup : null });
     }
-    if (movedExisting) {
-      movedExisting = false;
+    for (const details of suites.filter((item) => item.legacy.status === "migrate")) {
+      const backup = suiteTransactionPath(details, LEGACY_SKILL_NAME, "backup");
+      renameSync(details.legacy.target, backup);
+      migrated.push({ details, backup });
+    }
+  } catch (error) {
+    const rollbackFailures = [];
+    for (const item of migrated.reverse()) {
       try {
-        rmSync(backup, { recursive: true, force: true });
-      } catch {
-        // The verified target is already live; stale backup cleanup must not invalidate it.
+        renameSync(item.backup, item.details.legacy.target);
+      } catch (rollbackError) {
+        rollbackFailures.push(rollbackError);
       }
     }
-    return current.status === "absent" ? "installed" : "updated";
+    for (const item of switched.reverse()) {
+      try {
+        rmSync(item.entry.target, { recursive: true, force: true });
+        if (item.backup !== null) {
+          renameSync(item.backup, item.entry.target);
+        }
+      } catch (rollbackError) {
+        rollbackFailures.push(rollbackError);
+      }
+    }
+    if (rollbackFailures.length) {
+      throw new BootstrapError(
+        `Skill suite installation failed and rollback was incomplete: ${error.message}; rollback: ${rollbackFailures.map((failure) => failure.message).join("; ")}`,
+        3,
+      );
+    }
+    throw error;
   } finally {
-    rmSync(staging, { recursive: true, force: true });
-    if (movedExisting) {
+    for (const item of staged) {
+      rmSync(item.staging, { recursive: true, force: true });
+    }
+  }
+
+  for (const item of switched) {
+    if (item.backup !== null) {
       try {
-        renameSync(backup, details.target);
+        rmSync(item.backup, { recursive: true, force: true });
       } catch {
-        throw new BootstrapError(`Failed to restore previous msdevflow skill from ${backup}.`, 3);
+        // The verified replacement is live; stale backup cleanup can be retried manually.
       }
     }
   }
+  for (const item of migrated) {
+    try {
+      rmSync(item.backup, { recursive: true, force: true });
+    } catch {
+      // The legacy entry is no longer discoverable; stale backup cleanup is non-blocking.
+    }
+  }
+  return suites.map(installedSuiteResult);
 }
 
 function validatePythonRequirements(file) {
@@ -628,7 +790,7 @@ async function selectClientTargets(input, output, promptOutput = output) {
   promptOutput.write("No supported agent client was detected. Available targets: claude, codex, opencode, all.\n");
   const terminal = createInterface({ input, output: promptOutput });
   try {
-    const answer = await terminal.question("Install msdevflow for: ");
+    const answer = await terminal.question("Install the msd skill suite for: ");
     return parseTargets(answer);
   } finally {
     terminal.close();
@@ -653,7 +815,7 @@ async function resolveClientTargets(options, run, platform, selectClients) {
 function clientTargetWarnings(clients, layouts) {
   if (clients.includes("opencode") && layouts.length > 1) {
     return [
-      "OpenCode can discover msdevflow from both installed paths; keep both copies managed by this setup to prevent version drift.",
+      "OpenCode can discover the msd skill suite from both installed paths; keep both copies managed by this setup to prevent version drift.",
     ];
   }
   return [];
@@ -951,11 +1113,16 @@ function safeAuthStatus(output) {
 function printPlan(plan, write) {
   write("Setup plan (no changes made yet):");
   write(`  Client targets: ${plan.clientTargets.clients.join(", ")} (${plan.clientTargets.source})`);
-  write(`  Bundled skill: ${plan.skillInstalls[0].details.source}`);
+  write(`  Bundled skill suite: ${plan.skillInstalls[0].details.source}`);
   for (const { layout, details } of plan.skillInstalls) {
-    write(`  Skill target: ${details.target}`);
+    write(`  Skill root: ${details.target}`);
     write(`    Clients: ${layout.clients.join(", ")}`);
-    write(`    Action: ${details.status}`);
+    for (const entry of details.entries) {
+      write(`    ${entry.name}: ${entry.status}`);
+    }
+    if (details.legacy.status === "migrate") {
+      write(`    ${LEGACY_SKILL_NAME}: migrate after suite verification`);
+    }
   }
   for (const warning of plan.clientTargets.warnings) {
     write(`  Warning: ${warning}`);
@@ -1079,7 +1246,8 @@ function textResult(result, write) {
   write("Setup completed:");
   write(`  Client targets: ${result.clients.join(", ")}`);
   for (const skill of result.skills) {
-    write(`  Skill: ${skill.status} at ${skill.target} (${skill.clients.join(", ")})`);
+    write(`  Skill suite: ${skill.status} at ${skill.target} (${skill.clients.join(", ")})`);
+    write(`    Entries: ${skill.entries.map((entry) => entry.name).join(", ")}`);
   }
   for (const warning of result.warnings) {
     write(`  Warning: ${warning}`);
@@ -1124,7 +1292,10 @@ export async function runSetup(options, dependencies = {}) {
     options,
     targetSelection.clients,
     environment,
-    dependencies.bundledSkillDir,
+    dependencies.bundledSkillsDir
+      || (dependencies.bundledSkillDir
+        ? path.dirname(dependencies.bundledSkillDir)
+        : BUNDLED_SKILLS_DIR),
     platform,
   );
   const skillInstalls = layouts.map((layout) => ({
@@ -1220,14 +1391,17 @@ export async function runSetup(options, dependencies = {}) {
     progress,
     options.json,
   );
-  const skills = await progress.run("Installing msdevflow skill targets", async () => (
-    skillInstalls.map(({ layout, details }) => ({
-      kind: layout.kind,
-      clients: layout.clients,
-      status: installBundledSkill(details),
-      target: layout.workflowDir,
-    }))
-  ));
+  const skills = await progress.run("Installing msd skill suites", async () => {
+    const installedSuites = installBundledSkillSuites(
+      skillInstalls.map(({ details }) => details),
+    );
+    return installedSuites.map((installedSuite, index) => ({
+      kind: skillInstalls[index].layout.kind,
+      clients: skillInstalls[index].layout.clients,
+      target: skillInstalls[index].layout.skillsDir,
+      ...installedSuite,
+    }));
+  });
   const result = {
     state: "ready",
     git: gitVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msdevflow",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "Install the msdevflow GitCode skill and its runtime dependencies",
   "type": "module",
   "bin": {
@@ -10,7 +10,9 @@
     "bin/",
     "lib/",
     "skill/",
-    "!skill/msdevflow/scripts/test_openlibing_ci.py"
+    "!skill/**/scripts/test_openlibing_ci.py",
+    "!skill/**/__pycache__/**",
+    "!skill/**/*.pyc"
   ],
   "scripts": {
     "check": "node --check bin/msdevflow.js && node --check lib/bootstrap.js",

package/skill/{msdevflow → msd}/README.md

@@ -1,9 +1,26 @@
-# msdevflow
+# msd
 
-通用 GitCode Issue 到 PR 合入 workflow skill。它保留一个统一 skill，通过显式 `action` 单独执行某一部分；未指定 `action` 时，按远端和本地证据运行完整作者端到端流程。
+通用 GitCode Issue 到 PR 合入 workflow Skill 套件。业务规则只存在于核心 `msd`；十个 `msd-<action>` 薄路由 Skill 让 Claude Code、Codex 和 OpenCode 在输入阶段展示并补全可用 action。
 
 ## 1. Action 模型
 
+输入 `/msd-`（Claude Code/OpenCode）或 `$msd-`（Codex）即可筛选：
+
+```text
+msd-discover
+msd-create-issue
+msd-issue
+msd-develop
+msd-pr
+msd-ci
+msd-openlibing-auth
+msd-feedback
+msd-code-review
+msd-merge
+```
+
+每个薄路由只固定唯一 action、保留调用正文，并从相对路径 `../msd/SKILL.md` 加载同一 skills 根目录中的核心，不复制业务规则；核心 references 继续以 `../msd/` 为基准。直接调用核心 `msd` 会运行完整作者 E2E，不会在提交后弹出 Question 菜单；`/msd action=<name>`、`$msd action=<name>` 仍作为兼容调用，但参数本身没有跨客户端枚举下拉。
+
 支持：
 
 | action | 能力 | 完成后行为 |
@@ -28,7 +45,7 @@
 
 ## 2. 完整作者 E2E
 
-未指定 `action` 时，从环境、CLI 能力和仓库画像开始运行完整流程：
+直接调用核心 `msd` 且不提供 `action=` 时，从环境、CLI 能力和仓库画像开始运行完整流程：
 
 ```text
 discover -> issue -> develop -> pr -> ci
@@ -55,12 +72,12 @@ discover -> issue -> develop -> pr -> ci
 
 ## 4. 调用示例
 
-以下示例使用 Claude Code 的 `/msdevflow` 形式。Codex 使用 `$msdevflow`、`/skills` 或隐式匹配；OpenCode 使用 skill 工具或隐式匹配。无论客户端入口如何，正文中的 `action=<name>` 和其余任务参数保持相同。
+以下示例使用 Claude Code 的 `/msd` 形式。Codex 使用 `$msd`，OpenCode 可从 `/skills` 选择 `msd`；OpenCode 的 `@` 不用于 Skill。单项能力优先使用各客户端输入补全中的 `msd-<action>`，正文中的任务参数保持不变。
 
-### 未指定 action：完整 E2E
+### 运行完整 E2E
 
 ```text
-/msdevflow
+/msd
 处理 https://gitcode.com/Ascend/example/issues/123。
 本地仓库：D:\work\example
 canonical：Ascend/example
@@ -71,7 +88,7 @@ Fork：myname/example
 ### 只发现候选 Issue
 
 ```text
-/msdevflow action=discover
+/msd-discover
 查询 Ascend/example 中分配给当前账号的开放 Issue，列出仍需处理的候选。
 ```
 
@@ -80,7 +97,7 @@ Fork：myname/example
 ### 只创建 Issue
 
 ```text
-/msdevflow action=create-issue
+/msd-create-issue
 在 Ascend/example 提一个 bug：升级后首次启动失败，错误信息和环境如下……
 使用 guided 模式，先给我完整预览，确认后再创建。
 ```
@@ -92,7 +109,7 @@ Fork：myname/example
 ### 只接取和核验 Issue
 
 ```text
-/msdevflow action=issue
+/msd-issue
 处理 https://gitcode.com/Ascend/example/issues/123。
 本地仓库：D:\work\example
 ```
@@ -102,7 +119,7 @@ Fork：myname/example
 ### 只开发和本地验证
 
 ```text
-/msdevflow action=develop
+/msd-develop
 Issue：https://gitcode.com/Ascend/example/issues/123
 本地仓库：D:\work\example
 ```
@@ -112,7 +129,7 @@ Issue：https://gitcode.com/Ascend/example/issues/123
 ### 只创建 PR
 
 ```text
-/msdevflow action=pr
+/msd-pr
 Issue：https://gitcode.com/Ascend/example/issues/123
 本地仓库：D:\work\example
 canonical：Ascend/example
@@ -124,7 +141,7 @@ source：myname/example
 ### 只处理 CI
 
 ```text
-/msdevflow action=ci
+/msd-ci
 PR：https://gitcode.com/Ascend/example/pulls/456
 本地仓库：D:\work\example
 ```
@@ -134,7 +151,7 @@ CI 通过后立即停止，不处理 feedback 或 merge。识别为 openLiBing
 ### 只验证 openLiBing OAuth
 
 ```text
-/msdevflow action=openlibing-auth
+/msd-openlibing-auth
 本地仓库：D:\work\example
 ```
 
@@ -145,7 +162,7 @@ CI 通过后立即停止，不处理 feedback 或 merge。识别为 openLiBing
 ### 只处理自己 PR 的意见
 
 ```text
-/msdevflow action=feedback
+/msd-feedback
 PR：https://gitcode.com/Ascend/example/pulls/456
 本地仓库：D:\work\example
 ```
@@ -155,7 +172,7 @@ PR：https://gitcode.com/Ascend/example/pulls/456
 ### 检视他人的 PR
 
 ```text
-/msdevflow action=code-review
+/msd-code-review
 PR：https://gitcode.com/Ascend/example/pulls/789
 ```
 
@@ -166,7 +183,7 @@ PR：https://gitcode.com/Ascend/example/pulls/789
 ### 只核验并合入
 
 ```text
-/msdevflow action=merge
+/msd-merge
 PR：https://gitcode.com/Ascend/example/pulls/456
 ```
 
@@ -206,11 +223,11 @@ git --version
 <gitcode-command> auth login --web
 ```
 
-用户只在 GitCode CLI 打开的官方浏览器页面完成登录。不要把 Token 粘贴到对话、setup、README、项目文件或命令 URL 中；如需手动恢复认证，也优先在自己的终端运行同一 `--web` 命令。
+GitCode CLI 会打开官方页面让用户创建 Token，再在 CLI 自己的终端提示中接收粘贴内容并验证。Token 只能粘贴到该 CLI 提示；不要放入 Agent 对话、命令参数、项目文件、README、URL 或日志。`msdevflow` 父进程不读取或输出 Token；如需手动恢复认证，在自己的终端运行同一 `--web` 命令。
 
 ## 6. 安装
 
-npm 包同时携带 `msdevflow` skill 和 setup 程序。首次安装：
+npm 包 `msdevflow` 同时携带 `msd` Skill 套件和 setup 程序。首次安装：
 
 ```bash
 npx msdevflow setup
@@ -226,7 +243,7 @@ npx msdevflow@latest setup
 
 `setup` 默认检测 PATH 中的 Claude Code、Codex 和 OpenCode，先展示客户端、物理 skill 目标、安装或更新状态、GitCode CLI 归属、registry、安装模式、Python 依赖命令和认证方式；用户确认后，在同一次运行中：
 
-1. 从 npm 包内唯一源码 `skill/msdevflow` 原子安装或更新所需受管副本；
+1. 从 npm 包内的 `skill/msd` 核心和十个 `skill/msd-<action>` 路由器原子安装或更新整套入口；
 2. 安装或升级官方 GitCode npm CLI；
 3. 安装内置 `scripts/requirements.txt` 中的 Python Playwright 包；
 4. 验收 workflow 所需 schema/API；
@@ -235,15 +252,17 @@ npx msdevflow@latest setup
 客户端到物理目录的映射：
 
 ```text
-Claude Code            -> ~/.claude/skills/msdevflow
-Codex                  -> ~/.agents/skills/msdevflow
-仅 OpenCode            -> ~/.agents/skills/msdevflow
+Claude Code            -> ~/.claude/skills/{msd,msd-*}
+Codex                  -> ~/.agents/skills/{msd,msd-*}
+仅 OpenCode            -> ~/.agents/skills/{msd,msd-*}
 OpenCode + Claude Code -> 复用 Claude 目标
 OpenCode + Codex       -> 复用 Agent Skills 目标
-Claude Code + Codex    -> 两个受管副本
-三者同时安装           -> 两个受管副本，并提示 OpenCode 双路径发现
+Claude Code + Codex    -> 两套受管副本
+三者同时安装           -> 两套受管副本，并提示 OpenCode 双路径发现
 ```
 
+每个物理目标都包含一个 `msd` 核心和十个 `msd-<action>` 路由器；业务规则仍只有一份。
+
 显式选择客户端、只读预检或自定义目录：
 
 ```bash
@@ -263,7 +282,7 @@ npm 包尚未发布时，可从当前源码/发布目录运行等价入口：
 node ./msdevflow/bin/msdevflow.js setup
 ```
 
-`setup` 不下载或启动 Chromium。凭证只由 GitCode CLI 和官方浏览器流程接收与保存；setup 不读取、输出或转存 Token，也不要求用户把 Token 传给 Agent。每个已有 skill 目标只有 manifest 明确标识为 `msdevflow` 时才允许更新，来源不明的目录、文件或符号链接会被拒绝覆盖。安装后重启或重新加载对应客户端。
+`setup` 不下载或启动 Chromium。GitCode Token 只由 GitCode CLI 自己的终端提示接收并验证；setup 父进程不读取、输出或转存 Token，也不要求用户把 Token 传给 Agent。每个已有 `msd` 或 `msd-<action>` entry 的 manifest 都必须精确匹配自身名称才允许更新；来源不明的目录、文件或符号链接会阻断整套安装。旧 `msdevflow` 目录只有在 manifest 精确证明由本包管理时，才会在新套件全部切换并验证后安全迁移；失败时回滚整套变更。安装后重启或重新加载对应客户端。
 
 ## 7. 仓库画像和 PR 模板
 

package/skill/{msdevflow → msd}/SKILL.md

@@ -1,20 +1,43 @@
 ---
-name: msdevflow
+name: msd
 description: >
-  通用 GitCode Issue 到 PR 合入工作流。未指定 action 时，从环境与仓库画像开始，按远端和本地证据幂等推进完整作者流程；也支持通过 action=discover、create-issue、issue、develop、pr、ci、openlibing-auth、feedback、code-review 或 merge 只执行单个能力。适用于发现、新建或接取 GitCode Issue、开发并创建 PR、处理 CI、验证 openLiBing OAuth、处理自己 PR 的检视意见、检视他人 PR，以及在独立审批和显式确认后合入。仅适用于已授权的 GitCode 仓库。
+  通用 GitCode Issue 到 PR 合入工作流核心。直接调用 msd 时运行完整作者端到端流程；也接受 action=discover、create-issue、issue、develop、pr、ci、openlibing-auth、feedback、code-review 或 merge 兼容参数。推荐通过独立的 msd-<action> Skill 在输入时发现并选择单项能力。适用于发现、新建或接取 GitCode Issue、开发并创建 PR、处理 CI、验证 openLiBing OAuth、处理自己 PR 的检视意见、检视他人 PR，以及在独立审批和显式确认后合入。仅适用于已授权的 GitCode 仓库。
 compatibility: Requires Git, Node.js >=18, Python >=3.10, GitCode access, and the setup-installed GitCode CLI. Supports Claude Code, Codex, and OpenCode.
 metadata:
-  version: 2.0.0
+  version: 3.0.0
   source: msdevflow
+  role: core
 ---
 
-# msdevflow：GitCode Issue 到 PR 合入
+# msd：GitCode Issue 到 PR 合入
 
-把 GitCode 工作拆成可显式调用的 action，同时保留未指定 action 时的完整作者 E2E 编排。先探测仓库规范和 CLI 能力，不硬编码组织、默认分支、CI、分支命名、合并方式或机器人协议。
+把 GitCode 工作拆成可独立发现和调用的 action，不硬编码组织、默认分支、CI、分支命名、合并方式或机器人协议。安装套件同时提供核心 `msd` 和十个薄路由 Skill：Claude Code 与 OpenCode 输入 `/msd-`、Codex 输入 `$msd-`，即可在客户端的 Skill 补全中查看 action。
 
 ## Action 路由
 
-只识别显式参数 `action=<name>`。未知 action 停止并列出有效值，不做远端写入。
+推荐入口为 `msd-<action>`。薄路由 Skill 只固定一个 action、保留调用正文并加载本核心，不复制业务规则。核心也兼容字面量参数 `action=<name>`；显式 action 直接路由，未知 action 停止并列出有效值，不做远端写入。
+
+直接调用核心 `msd` 且没有 `action=` 时，运行完整作者 E2E，不显示运行时 Question 菜单，也不根据自然语言改成某个独立 action。完整 E2E 内部按权威证据定位当前阶段并渐进加载规则。
+
+若薄路由 Skill 固定的 action 与调用正文中的 `action=` 冲突，停止为 `blocked: action-conflict`，不得猜测或执行远端写入。
+
+可发现入口：
+
+```text
+msd
+msd-discover
+msd-create-issue
+msd-issue
+msd-develop
+msd-pr
+msd-ci
+msd-openlibing-auth
+msd-feedback
+msd-code-review
+msd-merge
+```
+
+薄路由选定后，等同于向本核心显式提供对应 `action=<name>`，并严格遵守显式 action 契约。
 
 | action | 目标 | 主要输入 | 完成后立即停止于 | 必读文件 |
 |---|---|---|---|---|
@@ -29,7 +52,7 @@ metadata:
 | `code-review` | 检视他人的 PR，发布 finding 或 `/lgtm` | 他人 PR | `review-findings`、`review-passed`、`review-incomplete`、`waiting` 或 `blocked` | [references/code-review.md](references/code-review.md) |
 | `merge` | 核验门禁并在最终确认后合入 | canonical PR | `merged`、`waiting` 或 `blocked` | [references/review-and-merge.md](references/review-and-merge.md) |
 
-`code-review` 只能显式调用，永不进入作者 E2E，不得检视或批准当前账号自己的 PR。它固定当前 head，完整检视权威 diff、必要上下文和既有 discussions：有高置信度问题时发布经确认且逐字回读的 finding，不发送 `/lgtm`；没有问题、没有有效未解决意见且覆盖完整时，在针对当前 PR/head 明确确认后先发布带尾签摘要，再原样发送 `/lgtm`。它不发送 `/approve`、`/merge`，不修改作者代码。
+`code-review` 只能通过 `msd-code-review` 或兼容参数 `action=code-review` 独立调用，永不进入作者 E2E，不得检视或批准当前账号自己的 PR。它固定当前 head，完整检视权威 diff、必要上下文和既有 discussions：有高置信度问题时发布经确认且逐字回读的 finding，不发送 `/lgtm`；没有问题、没有有效未解决意见且覆盖完整时，在针对当前 PR/head 明确确认后先发布带尾签摘要，再原样发送 `/lgtm`。它不发送 `/approve`、`/merge`，不修改作者代码。
 
 ## 显式 action 契约
 
@@ -41,9 +64,9 @@ metadata:
 6. `ci` 和完整 E2E 在 openLiBing 只读接口返回 401/403 时可运行 OAuth 认证子流程并恢复原流程；这是读取当前 CI 证据的必要步骤，不视为越界执行显式 `openlibing-auth` action。
 7. 所有远端写仍遵循 guided/autonomous 授权、UTF-8、尾签、幂等和最终 merge 确认规则。
 
-## 未指定 action：完整作者 E2E
+## 完整作者 E2E
 
-未提供 `action` 时，从 Phase 0 环境、CLI 能力和仓库画像开始运行完整流程；“从头开始”只表示重新读取事实，不表示重复创建资源或重复评论。按证据幂等跳过已完成步骤：
+直接调用核心 `msd` 且未提供 `action=` 时，从 Phase 0 环境、CLI 能力和仓库画像开始运行完整流程；调用正文可以提供完整 E2E 所需的 URL、路径、仓库和模式。“从头开始”只表示重新读取事实，不表示重复创建资源或重复评论。按证据幂等跳过已完成步骤：
 
 ```text
 discover -> issue -> develop -> pr -> ci
@@ -65,7 +88,7 @@ discover -> issue -> develop -> pr -> ci
 1. 固定 `gitcode_command`：无 Python 同名工具时为 `gitcode`；有 Python `gitcode` 时保留它并使用 `gitcode-npm`。来源不明时停止，不覆盖。
 2. 检查当前目录；若不是 Git 仓库，自动探测直接子目录中的 Git 仓库及 remotes。
 3. 确认 canonical repository、source repository、operation target、当前账号和授权范围。
-4. 除纯只读 `discover` 外，显式 action 先从 [references/setup-and-issue.md](references/setup-and-issue.md) 只读取公共环境、仓库上下文和最小充分仓库画像，不执行其中的 Issue 接取业务；随后只加载该 action 对应 reference 及实际触发的深层规则。`create-issue` 的模板选择和写入只按 [references/create-issue.md](references/create-issue.md)，不执行候选发现或既有 Issue 核验。`code-review` 只使用公共只读画像和 [references/code-review.md](references/code-review.md)，不加载作者 feedback/merge 规则。未指定 action 也只按当前位置渐进加载。
+4. 除纯只读 `discover` 外，显式 action 先从 [references/setup-and-issue.md](references/setup-and-issue.md) 只读取公共环境、仓库上下文和最小充分仓库画像，不执行其中的 Issue 接取业务；随后只加载该 action 对应 reference 及实际触发的深层规则。`create-issue` 的模板选择和写入只按 [references/create-issue.md](references/create-issue.md)，不执行候选发现或既有 Issue 核验。`code-review` 只使用公共只读画像和 [references/code-review.md](references/code-review.md)，不加载作者 feedback/merge 规则。完整作者 E2E 也只按当前位置渐进加载。
 5. CLI 缺失、命令不兼容或版本不足时读 [references/command-capabilities.md](references/command-capabilities.md)，停止当前 action 并提示用户运行独立 setup；setup 成功后恢复原 action。
 6. 进入 autonomous、远端写、危险动作或恢复时读 [references/state-and-safety.md](references/state-and-safety.md)。
 7. 中断恢复、写结果不确定或最终报告时读 [references/recovery.md](references/recovery.md)。

package/skill/{msdevflow → msd}/references/ci-and-review.md

@@ -107,7 +107,7 @@ commit/head SHA
    - 不采纳：spec/代码/测试依据；
 6. 统一换行为 `\n` 后逐字比较完整远端回复与预期正文，并验证末尾恰好存在一次尾签；发现 `?`、乱码、截断、尾签缺失、重复或其他不一致时先原地修复，未修复前不得 resolve；
 7. 正文回读通过后，仓库规则允许且权限具备时 resolve，再回读确认 `resolved=true`；
-8. 产生新 head 时，显式 `action=feedback` 停止并建议 `action=ci`；未指定 action 的完整作者 E2E 由编排器随后路由到 `ci`。
+8. 产生新 head 时，显式 `action=feedback` 停止并建议 `action=ci`；核心 `msd` 启动的完整作者 E2E 由编排器随后路由到 `ci`。
 
 不要只发一条总体总结替代逐条回复。汇总应在逐条闭环后发布。
 

package/skill/{msdevflow → msd}/references/create-issue.md

@@ -1,6 +1,6 @@
 # Action `create-issue`
 
-显式 `action=create-issue` 用于在一个已授权的 canonical repository 中创建一个 GitCode Issue。它是独立 action：创建并回读确认后立即停止，不执行 `discover`、`issue`、接取、查重、代码核验、开发或 PR 流程，也不进入未指定 action 的完整作者 E2E。
+显式 `action=create-issue` 用于在一个已授权的 canonical repository 中创建一个 GitCode Issue。它是独立 action：创建并回读确认后立即停止，不执行 `discover`、`issue`、接取、查重、代码核验、开发或 PR 流程，也不进入核心 `msd` 启动的完整作者 E2E。
 
 ## 输入和边界
 

package/skill/{msdevflow → msd}/references/design-and-development.md

@@ -1,6 +1,6 @@
 # Action `develop`：分析、设计与开发
 
-只在显式 `action=develop`，或未指定 action 的完整作者 E2E 已达到 `verified` 时读取。显式 action 启动时先只读确认 Issue 已核验且没有重复实现；前置不足时返回 `blocked` 并建议 `action=issue`，不得自动接取或补跑核验。
+只在显式 `action=develop`，或核心 `msd` 启动的完整作者 E2E 已达到 `verified` 时读取。显式 action 启动时先只读确认 Issue 已核验且没有重复实现；前置不足时返回 `blocked` 并建议 `action=issue`，不得自动接取或补跑核验。
 
 ## Phase 3：需求分析与设计决策树
 

package/skill/{msdevflow → msd}/references/pr-and-ci.md

@@ -1,6 +1,6 @@
 # Action `pr` 与 `ci`
 
-只在显式 `action=pr`、`action=ci`，或未指定 action 的完整作者 E2E 路由到对应位置时读取。任何远端写前同时读取 [state-and-safety.md](state-and-safety.md)。CI 触发或失败时再读取 [ci-and-review.md](ci-and-review.md)，不要提前加载。
+只在显式 `action=pr`、`action=ci`，或核心 `msd` 启动的完整作者 E2E 路由到对应位置时读取。任何远端写前同时读取 [state-and-safety.md](state-and-safety.md)。CI 触发或失败时再读取 [ci-and-review.md](ci-and-review.md)，不要提前加载。
 
 ## Action `pr`：Commit、Push、普通 PR
 

package/skill/{msdevflow → msd}/references/recovery.md

@@ -14,7 +14,7 @@
 4. 根据 action 完成条件识别最后一个有证据的状态；不能只信先前摘要或旧 run 产物。
 5. 验证本地分支与远端 source head 是否一致。
 6. 显式 action 只判断自身前置和完成条件：前置缺失时 `blocked`，不得运行上游；已完成时报告证据并立即停止。
-7. 未指定 action 的完整 E2E 从 Phase 0 重建仓库画像，再路由到下一未完成作者 action；不重复已完成的写操作。
+7. 核心 `msd` 启动的完整作者 E2E 从 Phase 0 重建仓库画像，再路由到下一未完成作者 action；不重复已完成的写操作。
 8. `create-issue` 不执行产品查重；仅在本次创建结果不确定时按目标仓库、当前账号、启动时间、标题和完整正文做有界恢复，无法唯一证明时停止。`openlibing-auth` 的历史 profile 或旧认证摘要不证明当前授权有效；必须用本次固定 run 做真实只读请求。
 9. `code-review` 不参与作者 E2E，也不从作者 feedback 状态恢复。恢复时重新确认 reviewer、author、PR 状态和当前 head；旧 `review_head_sha` 的分析、摘要、finding 或 `/lgtm` 不证明当前 head 已检视。
 10. 当前 head 等于旧 `review_head_sha` 时，回读结构化 comments/discussions，并按 reviewer、head、path/position 和完整正文恢复已发布 finding；检视通过必须同时回读到绑定当前 head 的带尾签摘要和同一 reviewer 的精确 `/lgtm`。

package/skill/{msdevflow → msd}/references/review-and-merge.md

@@ -1,6 +1,6 @@
 # Action `feedback` 与 `merge`
 
-只在显式 `action=feedback`、`action=merge`，或未指定 action 的完整作者 E2E 路由到对应位置时读取。开始时同时读取 [state-and-safety.md](state-and-safety.md)；处理结构化 discussion 或 CI 时按需读取 [ci-and-review.md](ci-and-review.md)。本文件不定义 `action=code-review`。
+只在显式 `action=feedback`、`action=merge`，或核心 `msd` 启动的完整作者 E2E 路由到对应位置时读取。开始时同时读取 [state-and-safety.md](state-and-safety.md)；处理结构化 discussion 或 CI 时按需读取 [ci-and-review.md](ci-and-review.md)。本文件不定义 `action=code-review`。
 
 ## Action `feedback`：处理自己 PR 的检视意见
 
@@ -31,7 +31,7 @@ PR 不存在时返回 `blocked` 并建议 `action=pr`；source branch 不可写
 6. 创建新 commit 并 push，不 amend、不 force push；
 7. 每条 discussion 在线程内回复：已修复引用 commit；部分采纳、不采纳或延期说明依据；每条回复按 [state-and-safety.md](state-and-safety.md) 使用 UTF-8 安全通道并附加唯一尾签，逐字回读完整正文；
 8. 只有回复正文和尾签回读一致后，仓库规则和权限允许时才 resolve；乱码、`?`、截断或不一致时先原地修复；
-9. 产生新 head 时记录旧 CI 结果已失效，停止后建议 `action=ci`；不得在显式 `feedback` 内触发或监控远端 CI。未指定 action 的完整 E2E 由编排器随后路由到 `ci`。
+9. 产生新 head 时记录旧 CI 结果已失效，停止后建议 `action=ci`；不得在显式 `feedback` 内触发或监控远端 CI。核心 `msd` 启动的完整作者 E2E 由编排器随后路由到 `ci`。
 
 不要以一条总体评论替代逐条回复。处理完成后不请求重新检视、不触发检视机器人；外部 reviewer 是否重新检视由仓库和人员流程决定。
 

package/skill/{msdevflow → msd}/references/setup-and-issue.md

@@ -1,6 +1,6 @@
 # Action `discover` 与 `issue`
 
-在显式 `action=discover`、`action=issue`，或未指定 action 的完整作者 E2E 启动时读取；显式 `action=create-issue` 只读取本文件的公共环境、仓库上下文和最小充分画像，模板和写入业务转到 [create-issue.md](create-issue.md)，不得执行本文件的发现、接取或重复实现核验。`discover` 全程只读并在候选报告后立即停止；`issue` 只接取和核验指定 Issue，达到 `verified` 后立即停止，不进入开发。
+在显式 `action=discover`、`action=issue`，或核心 `msd` 启动的完整作者 E2E 启动时读取；显式 `action=create-issue` 只读取本文件的公共环境、仓库上下文和最小充分画像，模板和写入业务转到 [create-issue.md](create-issue.md)，不得执行本文件的发现、接取或重复实现核验。`discover` 全程只读并在候选报告后立即停止；`issue` 只接取和核验指定 Issue，达到 `verified` 后立即停止，不进入开发。
 
 显式 `action=issue` 必须提供 Issue URL 或编号。缺少目标时只做确认输入缺失所需的只读核验，随后返回 `blocked` 并建议先运行 `action=discover`；不得在本 action 内查询候选、让用户选择 Issue 或执行 `discover` 的业务。
 
@@ -98,7 +98,7 @@ pr_number（如已有）
 
 ## Phase 1：发现与接取
 
-显式 `action=issue` 直接读取输入中的 Issue URL/编号；缺少目标时按本文件入口规则返回 `blocked`。显式 `action=discover` 或未指定 action 的完整作者 E2E 尚无目标时，才对“无目标发现”确认出的每个 canonical 查询当前用户负责的开放 Issue：
+显式 `action=issue` 直接读取输入中的 Issue URL/编号；缺少目标时按本文件入口规则返回 `blocked`。显式 `action=discover` 或核心 `msd` 启动的完整作者 E2E 尚无目标时，才对“无目标发现”确认出的每个 canonical 查询当前用户负责的开放 Issue：
 
 ```bash
 <gitcode-command> issue list -R <canonical> --state open --assignee <username> --json

package/skill/msd-ci/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: msd-ci
+description: 监控、诊断并修复当前 GitCode PR 的 CI，结果严格绑定当前 head SHA。
+compatibility: Requires the sibling msd core skill.
+metadata:
+  source: msdevflow
+  role: action-router
+  action: ci
+---
+
+# msd ci router
+
+先读取并完整遵循相对路径 `../msd/SKILL.md`（同一 skills 根目录中的 `msd` 核心），以固定参数 `action=ci` 执行；核心引用的相对路径均以 `../msd/` 为基准。原样保留本次调用正文中的 URL、路径、仓库、模式和其他参数；若正文包含不同的 `action=`，按核心规则停止为 `blocked: action-conflict`。无法读取核心时停止为 `blocked: core-skill-unavailable`。
+
+本路由只固定 action，不实现或复制业务规则。

package/skill/msd-code-review/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: msd-code-review
+description: 独立检视他人的 GitCode PR，发布高置信度 finding，或确认后评论精确的 /lgtm。
+compatibility: Requires the sibling msd core skill.
+metadata:
+  source: msdevflow
+  role: action-router
+  action: code-review
+---
+
+# msd code-review router
+
+先读取并完整遵循相对路径 `../msd/SKILL.md`（同一 skills 根目录中的 `msd` 核心），以固定参数 `action=code-review` 执行；核心引用的相对路径均以 `../msd/` 为基准。原样保留本次调用正文中的 URL、路径、仓库、模式和其他参数；若正文包含不同的 `action=`，按核心规则停止为 `blocked: action-conflict`。无法读取核心时停止为 `blocked: core-skill-unavailable`。
+
+本路由只固定 action，不实现或复制业务规则。

package/skill/msd-create-issue/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: msd-create-issue
+description: 按目标仓库或 Ascend community 的同类型模板创建一个 GitCode Issue，并回读验证。
+compatibility: Requires the sibling msd core skill.
+metadata:
+  source: msdevflow
+  role: action-router
+  action: create-issue
+---
+
+# msd create-issue router
+
+先读取并完整遵循相对路径 `../msd/SKILL.md`（同一 skills 根目录中的 `msd` 核心），以固定参数 `action=create-issue` 执行；核心引用的相对路径均以 `../msd/` 为基准。原样保留本次调用正文中的 URL、路径、仓库、模式和其他参数；若正文包含不同的 `action=`，按核心规则停止为 `blocked: action-conflict`。无法读取核心时停止为 `blocked: core-skill-unavailable`。
+
+本路由只固定 action，不实现或复制业务规则。

package/skill/msd-develop/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: msd-develop
+description: 分析并实现已核验的 GitCode Issue，从最新 canonical 基线建分支并完成本地验证。
+compatibility: Requires the sibling msd core skill.
+metadata:
+  source: msdevflow
+  role: action-router
+  action: develop
+---
+
+# msd develop router
+
+先读取并完整遵循相对路径 `../msd/SKILL.md`（同一 skills 根目录中的 `msd` 核心），以固定参数 `action=develop` 执行；核心引用的相对路径均以 `../msd/` 为基准。原样保留本次调用正文中的 URL、路径、仓库、模式和其他参数；若正文包含不同的 `action=`，按核心规则停止为 `blocked: action-conflict`。无法读取核心时停止为 `blocked: core-skill-unavailable`。
+
+本路由只固定 action，不实现或复制业务规则。

package/skill/msd-discover/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: msd-discover
+description: 只读发现当前 GitCode 账号负责且仍需处理的候选 Issue，并列出候选与排除证据。
+compatibility: Requires the sibling msd core skill.
+metadata:
+  source: msdevflow
+  role: action-router
+  action: discover
+---
+
+# msd discover router
+
+先读取并完整遵循相对路径 `../msd/SKILL.md`（同一 skills 根目录中的 `msd` 核心），以固定参数 `action=discover` 执行；核心引用的相对路径均以 `../msd/` 为基准。原样保留本次调用正文中的 URL、路径、仓库、模式和其他参数；若正文包含不同的 `action=`，按核心规则停止为 `blocked: action-conflict`。无法读取核心时停止为 `blocked: core-skill-unavailable`。
+
+本路由只固定 action，不实现或复制业务规则。

package/skill/msd-feedback/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: msd-feedback
+description: 处理当前账号自己 GitCode PR 的检视意见，验证并推送修改，逐条回复 discussion。
+compatibility: Requires the sibling msd core skill.
+metadata:
+  source: msdevflow
+  role: action-router
+  action: feedback
+---
+
+# msd feedback router
+
+先读取并完整遵循相对路径 `../msd/SKILL.md`（同一 skills 根目录中的 `msd` 核心），以固定参数 `action=feedback` 执行；核心引用的相对路径均以 `../msd/` 为基准。原样保留本次调用正文中的 URL、路径、仓库、模式和其他参数；若正文包含不同的 `action=`，按核心规则停止为 `blocked: action-conflict`。无法读取核心时停止为 `blocked: core-skill-unavailable`。
+
+本路由只固定 action，不实现或复制业务规则。

package/skill/msd-issue/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: msd-issue
+description: 接取并核验指定 GitCode Issue，检查关联 PR、默认分支和重复实现证据。
+compatibility: Requires the sibling msd core skill.
+metadata:
+  source: msdevflow
+  role: action-router
+  action: issue
+---
+
+# msd issue router
+
+先读取并完整遵循相对路径 `../msd/SKILL.md`（同一 skills 根目录中的 `msd` 核心），以固定参数 `action=issue` 执行；核心引用的相对路径均以 `../msd/` 为基准。原样保留本次调用正文中的 URL、路径、仓库、模式和其他参数；若正文包含不同的 `action=`，按核心规则停止为 `blocked: action-conflict`。无法读取核心时停止为 `blocked: core-skill-unavailable`。
+
+本路由只固定 action，不实现或复制业务规则。

package/skill/msd-merge/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: msd-merge
+description: 核验当前 GitCode PR 的 CI、discussion 和独立审批门禁，并在最终确认后合入。
+compatibility: Requires the sibling msd core skill.
+metadata:
+  source: msdevflow
+  role: action-router
+  action: merge
+---
+
+# msd merge router
+
+先读取并完整遵循相对路径 `../msd/SKILL.md`（同一 skills 根目录中的 `msd` 核心），以固定参数 `action=merge` 执行；核心引用的相对路径均以 `../msd/` 为基准。原样保留本次调用正文中的 URL、路径、仓库、模式和其他参数；若正文包含不同的 `action=`，按核心规则停止为 `blocked: action-conflict`。无法读取核心时停止为 `blocked: core-skill-unavailable`。
+
+本路由只固定 action，不实现或复制业务规则。

package/skill/msd-openlibing-auth/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: msd-openlibing-auth
+description: 在当前 canonical 仓库内固定一个 openLiBing run，并安全验证 GitCode OAuth 只读访问。
+compatibility: Requires the sibling msd core skill.
+metadata:
+  source: msdevflow
+  role: action-router
+  action: openlibing-auth
+---
+
+# msd openlibing-auth router
+
+先读取并完整遵循相对路径 `../msd/SKILL.md`（同一 skills 根目录中的 `msd` 核心），以固定参数 `action=openlibing-auth` 执行；核心引用的相对路径均以 `../msd/` 为基准。原样保留本次调用正文中的 URL、路径、仓库、模式和其他参数；若正文包含不同的 `action=`，按核心规则停止为 `blocked: action-conflict`。无法读取核心时停止为 `blocked: core-skill-unavailable`。
+
+本路由只固定 action，不实现或复制业务规则。

package/skill/msd-pr/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: msd-pr
+description: 复验本地实现后 commit、push，并创建和回读验证普通 GitCode PR。
+compatibility: Requires the sibling msd core skill.
+metadata:
+  source: msdevflow
+  role: action-router
+  action: pr
+---
+
+# msd pr router
+
+先读取并完整遵循相对路径 `../msd/SKILL.md`（同一 skills 根目录中的 `msd` 核心），以固定参数 `action=pr` 执行；核心引用的相对路径均以 `../msd/` 为基准。原样保留本次调用正文中的 URL、路径、仓库、模式和其他参数；若正文包含不同的 `action=`，按核心规则停止为 `blocked: action-conflict`。无法读取核心时停止为 `blocked: core-skill-unavailable`。
+
+本路由只固定 action，不实现或复制业务规则。