@hcmai/cli 0.2.1 → 0.3.1

package/dist/index.js

@@ -523,8 +523,8 @@ var init_TerminalRenderer = __esm({
         }
       }
       /** 来源行（仅子代理触发，agentPath ≥2 段时显示 `↑ 来自 a › b`，对齐 Web）。 */
-      originLine(path4) {
-        const segs = path4.split(".").filter(Boolean);
+      originLine(path7) {
+        const segs = path7.split(".").filter(Boolean);
         if (segs.length < 2) return "";
         const names = segs.map((k) => agentDisplayName(k));
         return chalk.gray(`  \u2191 \u6765\u81EA ${names.join(" \u203A ")}`) + "\n";
@@ -1458,10 +1458,10 @@ function ReplApp(props) {
       });
       const t0 = Date.now();
       try {
-        const result = await presenter.consume(handle.events);
+        const result2 = await presenter.consume(handle.events);
         const stats = presenter.completionStats;
-        if (result.status === "completed") {
-          bridge.showCompleted(Date.now() - t0, result.traceId, convRef.current ?? "", presenter.tokenCount || void 0, stats);
+        if (result2.status === "completed") {
+          bridge.showCompleted(Date.now() - t0, result2.traceId, convRef.current ?? "", presenter.tokenCount || void 0, stats);
         }
         if (presenter.tokenCount) setSessionTokens((prev) => prev + presenter.tokenCount);
         if (convRef.current) {
@@ -1706,8 +1706,8 @@ function agentLabel(agentId) {
   if (/^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(agentId)) return `agent \u2026${agentId.slice(-4)}`;
   return agentDisplayName(agentId);
 }
-function originLine(path4) {
-  const segs = (path4 ?? "").split(".").filter(Boolean);
+function originLine(path7) {
+  const segs = (path7 ?? "").split(".").filter(Boolean);
   if (segs.length < 2) return null;
   return `\u6765\u81EA ${segs.map((k) => agentDisplayName(k)).join(" \u203A ")}`;
 }
@@ -2639,12 +2639,12 @@ async function queryCommand(model, args) {
     if (args.offset) dsl.offset = Number(args.offset);
     if (!dsl.limit) dsl.limit = 20;
     const client3 = HcmClient.fromAuthContext(await getActiveAuthContextFromCli(args));
-    const result = await client3.query(model, dsl);
+    const result2 = await client3.query(model, dsl);
     const fmt = args.output ?? "table";
-    const out = formatRows(result.rows, { format: fmt });
+    const out = formatRows(result2.rows, { format: fmt });
     process.stdout.write(out + "\n");
-    if (fmt === "table" && result.total !== void 0) {
-      process.stdout.write(`Showing ${result.rows.length} of ${result.total} results.
+    if (fmt === "table" && result2.total !== void 0) {
+      process.stdout.write(`Showing ${result2.rows.length} of ${result2.total} results.
 `);
     }
     process.exit(0);
@@ -2709,17 +2709,17 @@ async function actionCommand(spec, args) {
       }
     }
     const client3 = HcmClient2.fromAuthContext(await getActiveAuthContextFromCli(args));
-    const result = await client3.action(model, action, input);
+    const result2 = await client3.action(model, action, input);
     const fmt = args.output ?? "json";
-    if (fmt !== "json" && result.taskId) {
+    if (fmt !== "json" && result2.taskId) {
       process.stdout.write(
-        `\u23F3 task created: ${result.taskId}  (use \`hcm task ${result.taskId}\` to follow up \u2014 coming Phase 1)
+        `\u23F3 task created: ${result2.taskId}  (use \`hcm task ${result2.taskId}\` to follow up \u2014 coming Phase 1)
 `
       );
     } else if (fmt !== "json") {
       process.stdout.write("\u2705 action succeeded\n");
     }
-    process.stdout.write(formatObject(result, { format: fmt }) + "\n");
+    process.stdout.write(formatObject(result2, { format: fmt }) + "\n");
     process.exit(0);
   } catch (e) {
     const err = e;
@@ -2808,11 +2808,11 @@ async function updateCommand(model, args) {
       });
     }
     const client3 = HcmClient4.fromAuthContext(await getActiveAuthContextFromCli(args));
-    const result = await client3.update(model, args.id, data);
+    const result2 = await client3.update(model, args.id, data);
     const fmt = args.output ?? "json";
     if (fmt !== "json") process.stdout.write(`\u2705 ${model}#${args.id} \u5DF2\u66F4\u65B0
 `);
-    process.stdout.write(formatObject3(result, { format: fmt }) + "\n");
+    process.stdout.write(formatObject3(result2, { format: fmt }) + "\n");
     process.exit(0);
   } catch (e) {
     const err = e;
@@ -2893,11 +2893,11 @@ async function settingSetCommand(domain, args) {
       process.exit(0);
     }
     const c = await client(args);
-    const result = await patchSettingDomain(c.raw(), domain, items);
+    const result2 = await patchSettingDomain(c.raw(), domain, items);
     const fmt = args.output ?? "json";
     if (fmt !== "json") process.stdout.write(`\u2705 ${domain} \u5DF2\u66F4\u65B0 ${items.length} \u9879
 `);
-    process.stdout.write(formatObject4(result, { format: fmt }) + "\n");
+    process.stdout.write(formatObject4(result2, { format: fmt }) + "\n");
     process.exit(0);
   } catch (e) {
     fail(e, args);
@@ -2914,11 +2914,11 @@ async function settingResetCommand(domain, namespace, key, args) {
     }
     const c = await client(args);
     const revision = args.revision === void 0 ? void 0 : Number(args.revision);
-    const result = await resetSettingItem(c.raw(), domain, namespace, key, revision);
+    const result2 = await resetSettingItem(c.raw(), domain, namespace, key, revision);
     const fmt = args.output ?? "json";
     if (fmt !== "json") process.stdout.write(`\u2705 ${namespace}.${key} \u5DF2\u56DE\u843D\u5230\u9ED8\u8BA4\u503C
 `);
-    process.stdout.write(formatObject4(result, { format: fmt }) + "\n");
+    process.stdout.write(formatObject4(result2, { format: fmt }) + "\n");
     process.exit(0);
   } catch (e) {
     fail(e, args);
@@ -3011,8 +3011,8 @@ import {
   formatObject as formatObject7,
   fromAxiosError as fromAxiosError8
 } from "@hcmai/sdk";
-function collectYmlFiles(path4) {
-  if (statSync(path4).isFile()) return [path4];
+function collectYmlFiles(path7) {
+  if (statSync(path7).isFile()) return [path7];
   const out = [];
   const walk = (dir) => {
     for (const name of readdirSync(dir).sort()) {
@@ -3021,7 +3021,7 @@ function collectYmlFiles(path4) {
       else if (full.endsWith(".yml") || full.endsWith(".yaml")) out.push(full);
     }
   };
-  walk(path4);
+  walk(path7);
   return out.sort();
 }
 var DRY_RUN_CLIENT = {
@@ -3029,9 +3029,9 @@ var DRY_RUN_CLIENT = {
   create: async () => ({ id: "" }),
   update: async () => ({})
 };
-async function importCommand(path4, args) {
+async function importCommand(path7, args) {
   try {
-    const files = collectYmlFiles(path4);
+    const files = collectYmlFiles(path7);
     const fixtures = files.map(
       (f) => parseFixture(readFileSync2(f, "utf8"), relative(process.cwd(), f))
     );
@@ -3041,16 +3041,16 @@ async function importCommand(path4, args) {
       onError: args.onError === "stop" ? "stop" : "continue"
     };
     const client3 = opts.dryRun ? DRY_RUN_CLIENT : HcmClient7.fromAuthContext(await getActiveAuthContextFromCli(args));
-    const result = await runImport(client3, fixtures, opts);
-    if (args.report) writeFileSync(args.report, JSON.stringify(result, null, 2));
+    const result2 = await runImport(client3, fixtures, opts);
+    if (args.report) writeFileSync(args.report, JSON.stringify(result2, null, 2));
     const fmt = args.output ?? "json";
     const tag = opts.dryRun ? "\u{1F50D} dry-run" : "\u{1F4E6} import";
     process.stdout.write(
-      `${tag}: created=${result.created} updated=${result.updated} skipped=${result.skipped} failed=${result.failed}
+      `${tag}: created=${result2.created} updated=${result2.updated} skipped=${result2.skipped} failed=${result2.failed}
 `
     );
-    process.stdout.write(formatObject7(result, { format: fmt }) + "\n");
-    process.exit(result.failed > 0 ? 3 : 0);
+    process.stdout.write(formatObject7(result2, { format: fmt }) + "\n");
+    process.exit(result2.failed > 0 ? 3 : 0);
   } catch (e) {
     const err = e;
     if (err?.isAxiosError) exitWithError(fromAxiosError8(err, args.profile));
@@ -3333,13 +3333,13 @@ async function printConversationList(args) {
   const ctx = await getActiveAuthContextFromCli(args);
   const client3 = HcmClient10.fromAuthContext(ctx);
   const limit = parsePositiveInt(args.limit, 10, "--limit");
-  const result = await fetchRecentConversations(client3.raw(), limit);
+  const result2 = await fetchRecentConversations(client3.raw(), limit);
   const fmt = args.output ?? "text";
   if (fmt === "json") {
-    process.stdout.write(formatObject9(result, { format: "json" }) + "\n");
+    process.stdout.write(formatObject9(result2, { format: "json" }) + "\n");
     return;
   }
-  const rows = result.rows.map((row) => ({
+  const rows = result2.rows.map((row) => ({
     UPDATED: formatShortDate(row.lastActiveAt ?? row.updateTime ?? row.createTime),
     MSGS: row.messageCount ?? 0,
     TOKENS: row.totalTokens ?? 0,
@@ -3347,8 +3347,8 @@ async function printConversationList(args) {
     CONVERSATION: row.id ?? "-"
   }));
   process.stdout.write(formatRows3(rows, { format: "table" }) + "\n");
-  if (result.total !== void 0) {
-    process.stdout.write(`Showing ${result.rows.length} of ${result.total} conversations.
+  if (result2.total !== void 0) {
+    process.stdout.write(`Showing ${result2.rows.length} of ${result2.total} conversations.
 `);
   }
 }
@@ -3620,9 +3620,9 @@ async function chatCommand(prompt, args) {
       process.once("SIGINT", sigintHandler);
       const t0 = Date.now();
       try {
-        const result = await presenter.consume(handle.events);
+        const result2 = await presenter.consume(handle.events);
         const stats = presenter.completionStats;
-        renderer.showCompleted(Date.now() - t0, result.traceId, handle.conversationId, presenter.tokenCount || void 0, {
+        renderer.showCompleted(Date.now() - t0, result2.traceId, handle.conversationId, presenter.tokenCount || void 0, {
           inputTokens: stats.inputTokens,
           outputTokens: stats.outputTokens,
           toolCount: stats.toolCount,
@@ -3631,8 +3631,8 @@ async function chatCommand(prompt, args) {
         await ws.close();
         await saveConversationState2(stateKey, {
           lastConversationId: handle.conversationId,
-          lastStreamId: result.streamId,
-          lastTraceId: result.traceId ?? void 0,
+          lastStreamId: result2.streamId,
+          lastTraceId: result2.traceId ?? void 0,
           lastAgentKey: args.agent,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
@@ -3644,7 +3644,7 @@ async function chatCommand(prompt, args) {
             resolve3();
           }
         });
-        process.exit(result.status === "interrupted" ? 130 : 0);
+        process.exit(result2.status === "interrupted" ? 130 : 0);
       } catch (e) {
         process.removeListener("SIGINT", sigintHandler);
         await ws.close();
@@ -4136,10 +4136,10 @@ async function withClient(args, fn) {
   const client3 = HcmClient13.fromAuthContext(await getActiveAuthContextFromCli(args));
   return fn(client3);
 }
-function emit(result, args, human) {
+function emit(result2, args, human) {
   const fmt = args.output ?? "json";
   if (fmt !== "json") process.stdout.write(human + "\n");
-  process.stdout.write(formatObject11(result, { format: fmt }) + "\n");
+  process.stdout.write(formatObject11(result2, { format: fmt }) + "\n");
   process.exit(0);
 }
 function fail2(e, args) {
@@ -4158,20 +4158,20 @@ async function cacheStatsCommand(model, args) {
 }
 async function cacheClearCommand(model, args) {
   try {
-    const result = await withClient(args, (c) => clearModelCache(c.raw(), model, args.id));
-    emit(result, args, args.id ? `\u{1F9F9} \u5DF2\u6E05 ${model}#${args.id} \u7F13\u5B58` : `\u{1F9F9} \u5DF2\u6E05 ${model} \u5168\u90E8\u5B9E\u4F53\u7F13\u5B58`);
+    const result2 = await withClient(args, (c) => clearModelCache(c.raw(), model, args.id));
+    emit(result2, args, args.id ? `\u{1F9F9} \u5DF2\u6E05 ${model}#${args.id} \u7F13\u5B58` : `\u{1F9F9} \u5DF2\u6E05 ${model} \u5168\u90E8\u5B9E\u4F53\u7F13\u5B58`);
   } catch (e) {
     fail2(e, args);
   }
 }
 async function cacheClearMetaCommand(model, args) {
   try {
-    const result = await withClient(
+    const result2 = await withClient(
       args,
       (c) => clearMetaCache(c.raw(), model, { type: args.type, state: args.state })
     );
     const scope = args.type ? `${args.type}${args.state ? `.${args.state}` : ""}` : "\u5168\u90E8";
-    emit(result, args, `\u{1F9F9} \u5DF2\u6E05 ${model} \u5143\u6570\u636E\u7F13\u5B58\uFF08${scope}\uFF09`);
+    emit(result2, args, `\u{1F9F9} \u5DF2\u6E05 ${model} \u5143\u6570\u636E\u7F13\u5B58\uFF08${scope}\uFF09`);
   } catch (e) {
     fail2(e, args);
   }
@@ -4224,20 +4224,21 @@ async function uploadCommand(filePath, args) {
 init_exit();
 import { promises as fsp } from "fs";
 import os2 from "os";
-import path2 from "path";
-import { createHash } from "crypto";
+import path4 from "path";
+import { createHash as createHash3 } from "crypto";
 import {
   createHttpClient as createHttpClient2,
   fetchSkillCatalog,
+  fetchSkillFile,
   fetchSkillMarkdown,
   fetchSkillReference,
   resolveChironBase,
-  assertSafeSkillId,
+  assertSafeSkillId as assertSafeSkillId2,
   assertSafeReferencePath,
-  normalizeReferences,
+  normalizeReferences as normalizeReferences2,
   parseSkillRequirements,
   parseSkillFrontmatter,
-  resolveSkillInstallOrder,
+  resolveSkillInstallOrder as resolveSkillInstallOrder2,
   resolveAllSkillsInstallOrder,
   flattenSkills,
   matchSkills,
@@ -4247,12 +4248,816 @@ import {
   loadEnv as loadEnv5,
   loadGlobalConfig as loadGlobalConfig6,
   resolveActiveEnv as resolveActiveEnv3,
+  CliError as CliError16,
+  CliErrorCode as CliErrorCode15
+} from "@hcmai/sdk";
+
+// src/commands/skills-sync.ts
+import { createHash } from "crypto";
+import { promises as fs4 } from "fs";
+import path2 from "path";
+import {
   CliError as CliError14,
-  CliErrorCode as CliErrorCode13
+  CliErrorCode as CliErrorCode13,
+  assertSafeSkillFilePath,
+  assertSafeSkillId,
+  normalizeReferences,
+  resolveSkillInstallOrder
 } from "@hcmai/sdk";
+async function prepareSkillDocuments(catalog, requestedSkill, fetchMarkdown, fetchFile, fetchReference) {
+  const order = resolveSkillInstallOrder(catalog, requestedSkill);
+  for (const skill of order) {
+    if (skill.actionSurface !== "cli") {
+      throw invalid(`\u6280\u80FD ${skill.id} \u5C1A\u672A\u6536\u655B\u5230 hcm CLI\uFF0C\u4E0D\u80FD\u540C\u6B65\u4E3A WorkBuddy \u6B63\u5F0F\u6267\u884C Skill`);
+    }
+  }
+  return Promise.all(
+    order.map(async (skill) => {
+      let files;
+      if (skill.files === void 0) {
+        const markdown2 = await fetchMarkdown(skill.id);
+        const content = Buffer.from(markdown2, "utf8");
+        const references = normalizeReferences(skill.references, skill.id);
+        if (references.length > 0 && !fetchReference) {
+          throw invalid(`\u6280\u80FD ${skill.id} \u58F0\u660E\u4E86 references\uFF0C\u4F46\u8C03\u7528\u65B9\u6CA1\u6709\u53C2\u8003\u6587\u4EF6\u4E0B\u8F7D\u80FD\u529B`);
+        }
+        const referenceFiles = await Promise.all(
+          references.map(async (relativePath) => {
+            const targetPath = `references/${relativePath}`;
+            assertSafeSkillFilePath(targetPath);
+            const fetched = await fetchReference(skill.id, relativePath);
+            const referenceContent = Buffer.isBuffer(fetched) ? Buffer.from(fetched) : Buffer.from(fetched, "utf8");
+            return {
+              path: targetPath,
+              content: referenceContent,
+              bytes: referenceContent.length,
+              sha256: sha256(referenceContent)
+            };
+          })
+        );
+        files = [
+          {
+            path: "SKILL.md",
+            content,
+            bytes: content.length,
+            sha256: sha256(content)
+          },
+          ...referenceFiles
+        ];
+      } else {
+        if (!Array.isArray(skill.files) || skill.files.length === 0) {
+          throw invalid(`\u6280\u80FD ${skill.id} \u7684 files \u76EE\u5F55\u4E3A\u7A7A`);
+        }
+        if (!fetchFile) throw invalid(`\u6280\u80FD ${skill.id} \u63D0\u4F9B\u5B8C\u6574\u76EE\u5F55\uFF0C\u4F46\u8C03\u7528\u65B9\u6CA1\u6709\u6587\u4EF6\u4E0B\u8F7D\u80FD\u529B`);
+        const seen = /* @__PURE__ */ new Set();
+        for (const file of skill.files) {
+          assertSafeSkillFilePath(file.path);
+          if (seen.has(file.path))
+            throw invalid(`\u6280\u80FD ${skill.id} \u7684 files \u5305\u542B\u91CD\u590D\u8DEF\u5F84: ${file.path}`);
+          seen.add(file.path);
+          if (!Number.isInteger(file.bytes) || file.bytes < 0 || !/^[a-f0-9]{64}$/.test(file.sha256)) {
+            throw invalid(`\u6280\u80FD ${skill.id} \u7684\u6587\u4EF6\u76EE\u5F55\u5143\u6570\u636E\u975E\u6CD5: ${file.path}`);
+          }
+        }
+        if (!seen.has("SKILL.md")) throw invalid(`\u6280\u80FD ${skill.id} \u7684\u5B8C\u6574\u76EE\u5F55\u7F3A\u5C11 SKILL.md`);
+        files = await Promise.all(
+          skill.files.map(async (file) => {
+            const content = Buffer.from(await fetchFile(skill.id, file.path));
+            if (content.length !== file.bytes) {
+              throw invalid(
+                `\u6280\u80FD ${skill.id}/${file.path} \u5B57\u8282\u6570\u4E0E\u76EE\u5F55\u4E0D\u4E00\u81F4\uFF1A\u76EE\u5F55=${file.bytes}\uFF0C\u5B9E\u9645=${content.length}`
+              );
+            }
+            const digest = sha256(content);
+            if (digest !== file.sha256) {
+              throw invalid(`\u6280\u80FD ${skill.id}/${file.path} \u6458\u8981\u4E0E\u76EE\u5F55\u4E0D\u4E00\u81F4`);
+            }
+            return { path: file.path, content, bytes: content.length, sha256: digest };
+          })
+        );
+      }
+      const root = files.find((file) => file.path === "SKILL.md");
+      if (!root) throw invalid(`\u6280\u80FD ${skill.id} \u7684\u5B8C\u6574\u76EE\u5F55\u7F3A\u5C11 SKILL.md`);
+      const markdown = root.content.toString("utf8");
+      if (!markdown.trim()) throw invalid(`\u6280\u80FD ${skill.id} \u5185\u5BB9\u4E3A\u7A7A`);
+      validateWorkBuddyFrontmatter(markdown, skill.id);
+      const bytes = root.bytes;
+      if (Number.isFinite(skill.bytes) && skill.bytes > 0 && skill.bytes !== bytes) {
+        throw invalid(`\u6280\u80FD ${skill.id} \u5B57\u8282\u6570\u4E0E\u76EE\u5F55\u4E0D\u4E00\u81F4\uFF1A\u76EE\u5F55=${skill.bytes}\uFF0C\u5B9E\u9645=${bytes}`);
+      }
+      return { id: skill.id, markdown, bytes, sha256: root.sha256, files };
+    })
+  );
+}
+async function syncWorkBuddyProject(input) {
+  const project = path2.resolve(input.project);
+  const metaDir = path2.join(project, ".hcm-delivery");
+  const skillsDir = path2.join(project, ".codebuddy", "skills");
+  const lockPath = path2.join(metaDir, "chiron.lock.json");
+  assertSafeSkillId(input.requestedSkill);
+  validatePreparedDocuments(input.documents, input.requestedSkill);
+  validatePreparedRuntime(input.runtime);
+  await recoverInterruptedSyncs(project, metaDir, lockPath);
+  const oldLock = await readLock(lockPath);
+  const skillEntries = input.documents.flatMap(
+    (document) => document.files.map((file) => [ownedFile(document.id, file.path), file])
+  );
+  const runtimeEntries = input.runtime.files.map((file) => [file.path, file]);
+  const desiredEntries = [
+    ...skillEntries,
+    ...runtimeEntries
+  ];
+  const desiredFiles = desiredEntries.map(([file]) => file);
+  const desiredByFile = new Map(desiredEntries);
+  const oldOwned = new Set(oldLock?.ownedFiles ?? []);
+  const oldDigestByFile = lockDigests(oldLock);
+  for (const file of oldOwned) validateOwnedFile(file);
+  for (const file of desiredFiles) {
+    const absolute = path2.join(project, file);
+    const current = await readOptionalBytes(absolute);
+    if (current !== void 0 && !oldOwned.has(file)) {
+      throw invalid(`\u76EE\u6807\u6587\u4EF6\u4E0D\u5C5E\u4E8E\u4E0A\u4E00\u4EFD Chiron \u9501\uFF0C\u62D2\u7EDD\u8986\u76D6\u987E\u95EE\u6587\u4EF6\uFF1A${file}`);
+    }
+  }
+  for (const file of oldOwned) {
+    const absolute = path2.join(project, file);
+    const current = await readOptionalBytes(absolute);
+    if (current === void 0) continue;
+    const expected = oldDigestByFile.get(file);
+    if (!expected || sha256(current) !== expected.sha256 || !await fileModeMatches(absolute, expected.mode)) {
+      throw invalid(`\u4E0A\u4E00\u4EFD\u9501\u62E5\u6709\u7684\u751F\u6210\u6587\u4EF6\u5DF2\u88AB\u4EBA\u5DE5\u4FEE\u6539\uFF0C\u62D2\u7EDD\u8986\u76D6\u6216\u6E05\u7406\uFF1A${file}`);
+    }
+  }
+  const newLock = {
+    schemaVersion: 1,
+    source: {
+      endpointOriginSha256: sha256(normalizeEndpoint(input.endpoint)),
+      catalogPath: "/skills.json",
+      catalogSha256: sha256(stableJson2(input.catalog))
+    },
+    selection: { requestedSkill: input.requestedSkill },
+    resolvedSkills: input.documents.map(({ id, bytes, sha256: digest, files: skillFiles }) => ({
+      id,
+      bytes,
+      sha256: digest,
+      files: skillFiles.map(({ path: filePath, bytes: fileBytes, sha256: fileSha256 }) => ({
+        path: filePath,
+        bytes: fileBytes,
+        sha256: fileSha256
+      }))
+    })),
+    runtime: {
+      capabilities: input.runtime.capabilities,
+      capabilitiesSha256: input.runtime.capabilitiesSha256,
+      launch: input.runtime.launch,
+      files: input.runtime.files.map(({ path: filePath, bytes, sha256: digest, mode }) => ({
+        path: filePath,
+        bytes,
+        sha256: digest,
+        mode
+      }))
+    },
+    ownedFiles: desiredFiles,
+    syncedAt: input.now ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (oldLock && sameLockContent(oldLock, newLock) && await desiredFilesMatch(project, desiredByFile)) {
+    return result(false, input, project, skillsDir, lockPath, [], []);
+  }
+  const obsolete = [...oldOwned].filter((file) => !desiredByFile.has(file));
+  await fs4.mkdir(metaDir, { recursive: true });
+  const staging = await fs4.mkdtemp(path2.join(metaDir, ".staging-"));
+  const stagedFiles = path2.join(staging, "new");
+  const backups = path2.join(staging, "backup");
+  const stagedLock = path2.join(staging, "chiron.lock.json");
+  const journalPath = path2.join(staging, "journal.json");
+  let journalReady = false;
+  try {
+    for (const [file, preparedFile2] of desiredByFile) {
+      const staged = path2.join(stagedFiles, file);
+      await fs4.mkdir(path2.dirname(staged), { recursive: true });
+      await fs4.writeFile(
+        staged,
+        preparedFile2.content,
+        preparedFile2.mode === void 0 ? void 0 : { mode: preparedFile2.mode }
+      );
+    }
+    await fs4.writeFile(stagedLock, `${JSON.stringify(newLock, null, 2)}
+`, "utf8");
+    const affected = [.../* @__PURE__ */ new Set([...desiredFiles, ...obsolete])];
+    for (const file of affected) {
+      const target = path2.join(project, file);
+      if (!await exists(target)) continue;
+      const backup = path2.join(backups, file);
+      await fs4.mkdir(path2.dirname(backup), { recursive: true });
+      await fs4.copyFile(target, backup);
+    }
+    const oldLockExisted = await exists(lockPath);
+    if (oldLockExisted) {
+      const backupLock = path2.join(backups, ".hcm-delivery", "chiron.lock.json");
+      await fs4.mkdir(path2.dirname(backupLock), { recursive: true });
+      await fs4.copyFile(lockPath, backupLock);
+    }
+    const journal = {
+      schemaVersion: 1,
+      project,
+      affectedFiles: affected,
+      oldLockExisted
+    };
+    await fs4.writeFile(journalPath, `${JSON.stringify(journal, null, 2)}
+`, "utf8");
+    journalReady = true;
+    for (const file of desiredFiles) {
+      const target = path2.join(project, file);
+      await fs4.mkdir(path2.dirname(target), { recursive: true });
+      await fs4.rm(target, { force: true });
+      await fs4.rename(path2.join(stagedFiles, file), target);
+    }
+    for (const file of obsolete) await fs4.unlink(path2.join(project, file)).catch(ignoreMissing);
+    await fs4.rm(lockPath, { force: true });
+    await fs4.rename(stagedLock, lockPath);
+    await fs4.unlink(journalPath);
+    journalReady = false;
+  } catch (cause) {
+    if (journalReady) await recoverStaging(project, staging, lockPath);
+    throw cause;
+  } finally {
+    await fs4.rm(staging, { recursive: true, force: true });
+  }
+  return result(
+    true,
+    input,
+    project,
+    skillsDir,
+    lockPath,
+    input.documents.map((document) => document.id),
+    [...new Set(obsolete.map(idFromOwnedFile).filter((id) => id !== void 0))]
+  );
+}
+async function recoverInterruptedSyncs(project, metaDir, lockPath) {
+  let entries;
+  try {
+    entries = await fs4.readdir(metaDir, { withFileTypes: true });
+  } catch (cause) {
+    if (cause.code === "ENOENT") return;
+    throw cause;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith(".staging-")) continue;
+    const staging = path2.join(metaDir, entry.name);
+    if (await exists(path2.join(staging, "journal.json"))) {
+      await recoverStaging(project, staging, lockPath);
+    }
+    await fs4.rm(staging, { recursive: true, force: true });
+  }
+}
+async function recoverStaging(project, staging, lockPath) {
+  const journalPath = path2.join(staging, "journal.json");
+  const journal = parseJournal(await fs4.readFile(journalPath, "utf8"), project);
+  const backups = path2.join(staging, "backup");
+  for (const file of journal.affectedFiles) {
+    const target = path2.join(project, file);
+    const backup = path2.join(backups, file);
+    if (await exists(backup)) {
+      await fs4.mkdir(path2.dirname(target), { recursive: true });
+      await fs4.rm(target, { force: true });
+      await fs4.rename(backup, target);
+    } else {
+      await fs4.rm(target, { force: true });
+    }
+  }
+  const backupLock = path2.join(backups, ".hcm-delivery", "chiron.lock.json");
+  if (journal.oldLockExisted) {
+    if (!await exists(backupLock)) throw invalid(`\u540C\u6B65\u6062\u590D\u7F3A\u5C11\u65E7\u9501\u5907\u4EFD\uFF1A${backupLock}`);
+    await fs4.mkdir(path2.dirname(lockPath), { recursive: true });
+    await fs4.rm(lockPath, { force: true });
+    await fs4.rename(backupLock, lockPath);
+  } else {
+    await fs4.rm(lockPath, { force: true });
+  }
+}
+function parseJournal(content, project) {
+  let journal;
+  try {
+    journal = JSON.parse(content);
+  } catch (cause) {
+    throw new CliError14({
+      code: CliErrorCode13.CONFIG_PARSE_ERROR,
+      message: "Chiron \u540C\u6B65\u6062\u590D\u65E5\u5FD7\u635F\u574F",
+      cause
+    });
+  }
+  if (journal.schemaVersion !== 1 || journal.project !== project || !Array.isArray(journal.affectedFiles) || typeof journal.oldLockExisted !== "boolean") {
+    throw invalid("Chiron \u540C\u6B65\u6062\u590D\u65E5\u5FD7\u5408\u540C\u4E0D\u5339\u914D\uFF0C\u62D2\u7EDD\u731C\u6D4B\u6062\u590D\u8303\u56F4");
+  }
+  for (const file of journal.affectedFiles) validateOwnedFile(file);
+  return journal;
+}
+function validatePreparedDocuments(documents, requestedSkill) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const document of documents) {
+    assertSafeSkillId(document.id);
+    if (seen.has(document.id)) throw invalid(`\u540C\u6B65\u95ED\u5305\u5305\u542B\u91CD\u590D\u6280\u80FD: ${document.id}`);
+    seen.add(document.id);
+    if (!document.markdown.trim()) throw invalid(`\u6280\u80FD ${document.id} \u5185\u5BB9\u4E3A\u7A7A`);
+    const paths = /* @__PURE__ */ new Set();
+    for (const file of document.files) {
+      assertSafeSkillFilePath(file.path);
+      if (paths.has(file.path)) throw invalid(`\u6280\u80FD ${document.id} \u5305\u542B\u91CD\u590D\u6587\u4EF6: ${file.path}`);
+      paths.add(file.path);
+      if (file.content.length !== file.bytes || sha256(file.content) !== file.sha256) {
+        throw invalid(`\u6280\u80FD ${document.id}/${file.path} \u7684\u5DF2\u51C6\u5907\u5185\u5BB9\u6458\u8981\u4E0D\u4E00\u81F4`);
+      }
+    }
+    const root = document.files.find((file) => file.path === "SKILL.md");
+    if (!root || !root.content.equals(Buffer.from(document.markdown, "utf8")) || root.bytes !== document.bytes || root.sha256 !== document.sha256) {
+      throw invalid(`\u6280\u80FD ${document.id} \u7684\u5DF2\u51C6\u5907\u5185\u5BB9\u6458\u8981\u4E0D\u4E00\u81F4`);
+    }
+  }
+  if (!seen.has(requestedSkill)) throw invalid(`\u540C\u6B65\u95ED\u5305\u4E0D\u5305\u542B\u76EE\u6807\u6280\u80FD: ${requestedSkill}`);
+}
+function validatePreparedRuntime(runtime) {
+  if (!Array.isArray(runtime.capabilities) || runtime.capabilities.length === 0) {
+    throw invalid("WorkBuddy CLI \u80FD\u529B\u96C6\u5408\u4E3A\u7A7A");
+  }
+  const capabilities = /* @__PURE__ */ new Set();
+  for (const capability of runtime.capabilities) {
+    if (!/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/.test(capability) || capabilities.has(capability)) {
+      throw invalid(`WorkBuddy CLI \u80FD\u529B\u6807\u8BC6\u975E\u6CD5\u6216\u91CD\u590D\uFF1A${capability}`);
+    }
+    capabilities.add(capability);
+  }
+  if (!validDigest(runtime.capabilitiesSha256) || runtime.capabilitiesSha256 !== sha256(`${runtime.capabilities.join("\n")}
+`)) {
+    throw invalid("WorkBuddy CLI \u80FD\u529B\u6458\u8981\u4E0D\u4E00\u81F4");
+  }
+  if (!validDigest(runtime.launch.executableSha256)) {
+    throw invalid("WorkBuddy CLI \u53EF\u6267\u884C\u6587\u4EF6\u6458\u8981\u975E\u6CD5");
+  }
+  if (runtime.launch.kind === "node-entry" && !validDigest(runtime.launch.entrySha256)) {
+    throw invalid("WorkBuddy CLI \u5165\u53E3\u6458\u8981\u975E\u6CD5");
+  }
+  if (!Array.isArray(runtime.files) || runtime.files.length !== 2) {
+    throw invalid("WorkBuddy \u8FD0\u884C\u5165\u53E3\u5FC5\u987B\u540C\u65F6\u5305\u542B Unix \u4E0E Windows \u6587\u4EF6");
+  }
+  const files = /* @__PURE__ */ new Set();
+  for (const file of runtime.files) {
+    validateRuntimeFile(file);
+    if (files.has(file.path)) throw invalid(`WorkBuddy \u8FD0\u884C\u5165\u53E3\u91CD\u590D\uFF1A${file.path}`);
+    files.add(file.path);
+  }
+  if (!files.has(".hcm-delivery/bin/hcm") || !files.has(".hcm-delivery/bin/hcm.cmd")) {
+    throw invalid("WorkBuddy \u8FD0\u884C\u5165\u53E3\u5408\u540C\u4E0D\u5B8C\u6574");
+  }
+}
+function validateRuntimeFile(file) {
+  validateOwnedFile(file.path);
+  if (file.content.length !== file.bytes || sha256(file.content) !== file.sha256 || !Number.isInteger(file.mode) || file.mode < 0 || file.mode > 511) {
+    throw invalid(`WorkBuddy \u8FD0\u884C\u5165\u53E3\u6458\u8981\u6216\u6743\u9650\u4E0D\u4E00\u81F4\uFF1A${file.path}`);
+  }
+}
+function validateWorkBuddyFrontmatter(markdown, skillId) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(markdown);
+  if (!match) throw invalid(`\u6280\u80FD ${skillId} \u7F3A\u5C11 YAML frontmatter`);
+  const frontmatter = match[1] ?? "";
+  const name = /^name:\s*['"]?([^'"\s]+)['"]?\s*$/m.exec(frontmatter)?.[1];
+  const description = /^description:\s*(.+)$/m.exec(frontmatter)?.[1]?.trim();
+  if (name !== skillId) throw invalid(`\u6280\u80FD ${skillId} \u7684 frontmatter name \u4E0D\u4E00\u81F4`);
+  if (!description) throw invalid(`\u6280\u80FD ${skillId} \u7F3A\u5C11 description\uFF0CWorkBuddy \u65E0\u6CD5\u53D1\u73B0`);
+}
+async function readLock(lockPath) {
+  const content = await readOptional(lockPath);
+  if (content === void 0) return void 0;
+  try {
+    const lock = JSON.parse(content);
+    if (lock.schemaVersion !== 1 || !lock.source || !lock.selection?.requestedSkill || !Array.isArray(lock.resolvedSkills) || !Array.isArray(lock.ownedFiles)) {
+      throw new Error("schema mismatch");
+    }
+    assertSafeSkillId(lock.selection.requestedSkill);
+    for (const skill of lock.resolvedSkills) {
+      assertSafeSkillId(skill.id);
+      if (!Number.isInteger(skill.bytes) || skill.bytes < 0 || !/^[a-f0-9]{64}$/.test(skill.sha256)) {
+        throw new Error("invalid skill digest");
+      }
+      if (skill.files !== void 0) {
+        if (!Array.isArray(skill.files) || skill.files.length === 0)
+          throw new Error("invalid files");
+        const seen = /* @__PURE__ */ new Set();
+        for (const file of skill.files) {
+          assertSafeSkillFilePath(file.path);
+          if (seen.has(file.path) || !Number.isInteger(file.bytes) || file.bytes < 0 || !/^[a-f0-9]{64}$/.test(file.sha256)) {
+            throw new Error("invalid file digest");
+          }
+          seen.add(file.path);
+        }
+        if (!seen.has("SKILL.md")) throw new Error("missing SKILL.md");
+      }
+    }
+    if (lock.runtime !== void 0) validateLockedRuntime(lock.runtime);
+    for (const file of lock.ownedFiles) validateOwnedFile(file);
+    return lock;
+  } catch (cause) {
+    throw new CliError14({
+      code: CliErrorCode13.CONFIG_PARSE_ERROR,
+      message: `Chiron \u9501\u6587\u4EF6\u635F\u574F\uFF0C\u62D2\u7EDD\u731C\u6D4B\u6587\u4EF6\u6240\u6709\u6743\uFF1A${lockPath}`,
+      cause
+    });
+  }
+}
+function validateLockedRuntime(runtime) {
+  if (!Array.isArray(runtime.capabilities) || runtime.capabilities.length === 0 || !validDigest(runtime.capabilitiesSha256) || runtime.capabilitiesSha256 !== sha256(`${runtime.capabilities.join("\n")}
+`) || !runtime.launch || !validDigest(runtime.launch.executableSha256) || !Array.isArray(runtime.files) || runtime.files.length !== 2) {
+    throw new Error("invalid runtime");
+  }
+  if (runtime.launch.kind === "node-entry") {
+    if (!validDigest(runtime.launch.entrySha256)) throw new Error("invalid runtime entry");
+  } else if (runtime.launch.kind !== "executable") {
+    throw new Error("invalid runtime launch kind");
+  }
+  const capabilities = /* @__PURE__ */ new Set();
+  for (const capability of runtime.capabilities) {
+    if (!/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/.test(capability) || capabilities.has(capability)) {
+      throw new Error("invalid runtime capability");
+    }
+    capabilities.add(capability);
+  }
+  const files = /* @__PURE__ */ new Set();
+  for (const file of runtime.files) {
+    validateOwnedFile(file.path);
+    if (files.has(file.path) || !Number.isInteger(file.bytes) || file.bytes < 0 || !validDigest(file.sha256) || !Number.isInteger(file.mode) || file.mode < 0 || file.mode > 511) {
+      throw new Error("invalid runtime file");
+    }
+    files.add(file.path);
+  }
+  if (!files.has(".hcm-delivery/bin/hcm") || !files.has(".hcm-delivery/bin/hcm.cmd")) {
+    throw new Error("missing runtime file");
+  }
+}
+function sameLockContent(left, right) {
+  const withoutTime = (lock) => ({ ...lock, syncedAt: void 0 });
+  return stableJson2(withoutTime(left)) === stableJson2(withoutTime(right));
+}
+async function desiredFilesMatch(project, desired) {
+  for (const [file, preparedFile2] of desired) {
+    const absolute = path2.join(project, file);
+    const current = await readOptionalBytes(absolute);
+    if (current === void 0 || sha256(current) !== preparedFile2.sha256 || !await fileModeMatches(absolute, preparedFile2.mode)) {
+      return false;
+    }
+  }
+  return true;
+}
+function result(changed, input, project, skillsDir, lockPath, installed, removed) {
+  return {
+    changed,
+    requestedSkill: input.requestedSkill,
+    resolvedSkills: input.documents.map((document) => document.id),
+    project,
+    skillsDir,
+    lockPath,
+    runnerPath: path2.join(project, ".hcm-delivery", "bin", "hcm"),
+    capabilitiesSha256: input.runtime.capabilitiesSha256,
+    installed,
+    removed
+  };
+}
+function ownedFile(id, relativePath = "SKILL.md") {
+  assertSafeSkillId(id);
+  assertSafeSkillFilePath(relativePath);
+  return `.codebuddy/skills/${id}/${relativePath}`;
+}
+function idFromOwnedFile(file) {
+  validateOwnedFile(file);
+  if (!file.startsWith(".codebuddy/skills/")) return void 0;
+  return file.split("/")[2] ?? "";
+}
+function validateOwnedFile(file) {
+  if (file === ".hcm-delivery/bin/hcm" || file === ".hcm-delivery/bin/hcm.cmd") return;
+  const match = /^\.codebuddy\/skills\/([a-z0-9][a-z0-9-]{0,63})\/(.+)$/.exec(file);
+  if (!match) throw invalid(`\u9501\u6587\u4EF6\u5305\u542B\u975E\u6CD5\u6240\u6709\u6743\u8DEF\u5F84\uFF1A${file}`);
+  const id = match[1];
+  const relativePath = match[2];
+  if (!id || !relativePath) throw invalid(`\u9501\u6587\u4EF6\u5305\u542B\u975E\u6CD5\u6240\u6709\u6743\u8DEF\u5F84\uFF1A${file}`);
+  assertSafeSkillId(id);
+  try {
+    assertSafeSkillFilePath(relativePath);
+  } catch {
+    throw invalid(`\u9501\u6587\u4EF6\u5305\u542B\u975E\u6CD5\u6240\u6709\u6743\u8DEF\u5F84\uFF1A${file}`);
+  }
+}
+function normalizeEndpoint(endpoint) {
+  let url;
+  try {
+    url = new URL(endpoint);
+  } catch (cause) {
+    throw new CliError14({
+      code: CliErrorCode13.INVALID_ARGUMENT,
+      message: `\u975E\u6CD5 endpoint\uFF1A${endpoint}`,
+      cause
+    });
+  }
+  url.username = "";
+  url.password = "";
+  url.search = "";
+  url.hash = "";
+  url.pathname = url.pathname.replace(/\/+$/, "");
+  return url.toString().replace(/\/$/, "");
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function stableJson2(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson2).join(",")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableJson2(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+async function readOptional(file) {
+  try {
+    return await fs4.readFile(file, "utf8");
+  } catch (cause) {
+    if (cause.code === "ENOENT") return void 0;
+    throw cause;
+  }
+}
+async function readOptionalBytes(file) {
+  try {
+    return await fs4.readFile(file);
+  } catch (cause) {
+    if (cause.code === "ENOENT") return void 0;
+    throw cause;
+  }
+}
+async function exists(file) {
+  try {
+    await fs4.access(file);
+    return true;
+  } catch (cause) {
+    if (cause.code === "ENOENT") return false;
+    throw cause;
+  }
+}
+function lockDigests(lock) {
+  const digests = /* @__PURE__ */ new Map();
+  for (const skill of lock?.resolvedSkills ?? []) {
+    if (skill.files === void 0) {
+      digests.set(ownedFile(skill.id), { sha256: skill.sha256 });
+      continue;
+    }
+    for (const file of skill.files) {
+      digests.set(ownedFile(skill.id, file.path), { sha256: file.sha256 });
+    }
+  }
+  for (const file of lock?.runtime?.files ?? []) {
+    digests.set(file.path, { sha256: file.sha256, mode: file.mode });
+  }
+  return digests;
+}
+async function fileModeMatches(file, expected) {
+  if (expected === void 0 || process.platform === "win32") return true;
+  const stat = await fs4.stat(file);
+  return (stat.mode & 511) === expected;
+}
+function validDigest(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function ignoreMissing(cause) {
+  if (cause.code !== "ENOENT") throw cause;
+}
+function invalid(message) {
+  return new CliError14({ code: CliErrorCode13.INVALID_ARGUMENT, message });
+}
+
+// src/commands/skills-runtime.ts
+import { execFile } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { createReadStream, promises as fs5 } from "fs";
+import path3 from "path";
+import { promisify } from "util";
+import { CliError as CliError15, CliErrorCode as CliErrorCode14 } from "@hcmai/sdk";
+var execFileAsync = promisify(execFile);
+var REQUIRED_CAPABILITIES = [
+  "hcm.help.skills",
+  "hcm.skills.help.sync",
+  "hcm.skills.sync.option.project",
+  "hcm.skills.sync.option.target"
+];
+async function prepareWorkBuddyRuntime(input = {}) {
+  const candidate = input.candidate?.trim() || input.currentEntry || process.argv[1];
+  if (!candidate) throw invalid2("\u65E0\u6CD5\u89E3\u6790\u5F53\u524D HCM CLI \u5165\u53E3\uFF1B\u8BF7\u4F20 --cli <path>");
+  const launch = await resolveLaunch(candidate, input.nodeExecutable ?? process.execPath);
+  const launchTarget = launch.kind === "node-entry" ? launch.entry : launch.executable;
+  for (const forbidden2 of input.forbiddenCandidatePaths ?? []) {
+    if (await comparablePath(forbidden2) === launchTarget) {
+      throw invalid2("\u5019\u9009 HCM CLI \u4E0D\u80FD\u6307\u5411\u5F85\u751F\u6210\u7684\u9879\u76EE\u7A33\u5B9A\u5165\u53E3");
+    }
+  }
+  if (!(input.currentEntryHasRequiredCapabilities && !input.candidate?.trim())) {
+    const beforeProbe = await launchIdentity(launch);
+    const syncHelp = await runProbe(launch, ["skills", "sync", "--help"], input.timeoutMs).catch(
+      () => ""
+    );
+    const missing = [];
+    if (!/\bhcm\s+skills\s+sync\b/.test(syncHelp)) {
+      missing.push(REQUIRED_CAPABILITIES[0], REQUIRED_CAPABILITIES[1]);
+    }
+    if (!/--project(?:\s|=|<|\[|$)/.test(syncHelp)) missing.push(REQUIRED_CAPABILITIES[2]);
+    if (!/--target(?:\s|=|<|\[|$)/.test(syncHelp)) missing.push(REQUIRED_CAPABILITIES[3]);
+    if (missing.length > 0) {
+      throw invalid2(`\u5019\u9009 HCM CLI \u7F3A\u5C11 WorkBuddy \u6240\u9700\u80FD\u529B\uFF1A${missing.join(", ")}`);
+    }
+    if (await launchIdentity(launch) !== beforeProbe) {
+      throw invalid2("\u5019\u9009 HCM CLI \u5728\u80FD\u529B\u63A2\u9488\u671F\u95F4\u53D1\u751F\u53D8\u5316\uFF0C\u8BF7\u91CD\u8BD5\u540C\u6B65");
+    }
+  }
+  const capabilities = [...REQUIRED_CAPABILITIES];
+  const capabilitiesSha256 = sha2562(`${capabilities.join("\n")}
+`);
+  const executableSha256 = await sha256File(launch.executable);
+  const launchRecord = launch.kind === "node-entry" ? {
+    kind: "node-entry",
+    executableSha256,
+    entrySha256: await sha256File(launch.entry)
+  } : { kind: "executable", executableSha256 };
+  const unixContent = Buffer.from(unixLauncher(launch), "utf8");
+  const windowsContent = Buffer.from(windowsLauncher(launch), "utf8");
+  return {
+    capabilities,
+    capabilitiesSha256,
+    launch: launchRecord,
+    files: [
+      preparedFile(".hcm-delivery/bin/hcm", unixContent, 493),
+      preparedFile(".hcm-delivery/bin/hcm.cmd", windowsContent, 420)
+    ]
+  };
+}
+async function resolveLaunch(candidate, nodeExecutable) {
+  const requested = path3.resolve(candidate);
+  const resolvedCandidate = await realFile(requested, "\u5019\u9009 HCM CLI");
+  const header = (await readPrefix(resolvedCandidate, 256)).toString("utf8");
+  const nodeEntry = /^(?:#![^\r\n]*\bnode\b)|\.(?:c|m)?js$/i.test(
+    header.startsWith("#!") ? header.split(/\r?\n/, 1)[0] ?? "" : resolvedCandidate
+  );
+  if (nodeEntry) {
+    return {
+      kind: "node-entry",
+      executable: await realFile(path3.resolve(nodeExecutable), "Node \u53EF\u6267\u884C\u6587\u4EF6"),
+      entry: resolvedCandidate
+    };
+  }
+  return { kind: "executable", executable: resolvedCandidate };
+}
+async function realFile(file, label) {
+  try {
+    const resolved = await fs5.realpath(file);
+    const stat = await fs5.stat(resolved);
+    if (!stat.isFile()) throw new Error("not a regular file");
+    return resolved;
+  } catch (cause) {
+    throw new CliError15({
+      code: CliErrorCode14.INVALID_ARGUMENT,
+      message: `${label}\u4E0D\u53EF\u7528\uFF1A${file}`,
+      cause
+    });
+  }
+}
+async function comparablePath(file) {
+  const absolute = path3.resolve(file);
+  return fs5.realpath(absolute).catch(() => absolute);
+}
+async function launchIdentity(launch) {
+  const files = launch.kind === "node-entry" ? [launch.executable, launch.entry] : [launch.executable];
+  const identities = await Promise.all(
+    files.map(async (file) => {
+      const stat = await fs5.stat(file, { bigint: true });
+      return [file, stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].map(String).join("\0");
+    })
+  );
+  return identities.join("\n");
+}
+async function readPrefix(file, bytes) {
+  const handle = await fs5.open(file, "r");
+  try {
+    const buffer = Buffer.alloc(bytes);
+    const result2 = await handle.read(buffer, 0, bytes, 0);
+    return buffer.subarray(0, result2.bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+async function runProbe(launch, args, timeoutMs = 5e3) {
+  const command = launch.executable;
+  const commandArgs = launch.kind === "node-entry" ? [launch.entry, ...args] : args;
+  const env2 = {
+    ...process.env,
+    CI: "1",
+    NO_COLOR: "1",
+    HCM_RUNTIME_PROBE: "1"
+  };
+  const nodeOptions = normalizeWorkBuddyNodeOptions(env2.NODE_OPTIONS);
+  if (nodeOptions === void 0) delete env2.NODE_OPTIONS;
+  else env2.NODE_OPTIONS = nodeOptions;
+  try {
+    const { stdout, stderr } = await execFileAsync(command, commandArgs, {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      maxBuffer: 256 * 1024,
+      windowsHide: true,
+      env: env2
+    });
+    return `${stdout}
+${stderr}`;
+  } catch (cause) {
+    throw new CliError15({
+      code: CliErrorCode14.INVALID_ARGUMENT,
+      message: `\u5019\u9009 HCM CLI \u80FD\u529B\u63A2\u9488\u5931\u8D25\uFF1Ahcm ${args.join(" ")}`,
+      cause
+    });
+  }
+}
+function unixLauncher(launch) {
+  const command = shellQuote(launch.executable);
+  const entry = launch.kind === "node-entry" ? ` ${shellQuote(launch.entry)}` : "";
+  return `#!/bin/sh
+set -eu
+
+# WorkBuddy on macOS may inject --use-system-ca. Node can then spend minutes
+# evaluating the Keychain when a short-lived CLI process exits. Preserve every
+# other host option (including safety --require hooks) and change only this CA mode.
+wb_node_options="\${NODE_OPTIONS-}"
+if [ "$(uname -s 2>/dev/null || printf '%s' unknown)" = 'Darwin' ] &&   printf '%s
+' "$wb_node_options" | grep -Eq '(^|[[:space:]])--use-system-ca([[:space:]]|$)'; then
+  while printf '%s
+' "$wb_node_options" | grep -Eq '(^|[[:space:]])--use-system-ca([[:space:]]|$)'; do
+    wb_next_options="$(printf '%s
+' "$wb_node_options" | sed -E 's/(^|[[:space:]])--use-system-ca([[:space:]]|$)/\\1\\2/g')"
+    [ "$wb_next_options" != "$wb_node_options" ] || break
+    wb_node_options="$wb_next_options"
+  done
+  if ! printf '%s
+' "$wb_node_options" | grep -Eq '(^|[[:space:]])--use-bundled-ca([[:space:]]|$)'; then
+    wb_node_options="\${wb_node_options:+$wb_node_options }--use-bundled-ca"
+  fi
+  NODE_OPTIONS="$wb_node_options"
+  export NODE_OPTIONS
+fi
+
+exec ${command}${entry} "$@"
+`;
+}
+function normalizeWorkBuddyNodeOptions(value, platform = process.platform) {
+  if (platform !== "darwin" || value === void 0) return value;
+  const systemCa = /(^|[\t\n\r ])--use-system-ca(?=$|[\t\n\r ])/;
+  if (!systemCa.test(value)) return value;
+  let normalized = value;
+  while (systemCa.test(normalized)) normalized = normalized.replace(systemCa, "$1");
+  normalized = normalized.trim();
+  const bundledCa = /(^|[\t\n\r ])--use-bundled-ca(?=$|[\t\n\r ])/;
+  if (!bundledCa.test(normalized)) {
+    normalized = `${normalized}${normalized ? " " : ""}--use-bundled-ca`;
+  }
+  return normalized;
+}
+function windowsLauncher(launch) {
+  const command = cmdQuote(launch.executable);
+  const entry = launch.kind === "node-entry" ? ` ${cmdQuote(launch.entry)}` : "";
+  return `@echo off\r
+${command}${entry} %*\r
+`;
+}
+function shellQuote(value) {
+  if (/[\r\n\0]/.test(value)) throw invalid2("CLI \u542F\u52A8\u8DEF\u5F84\u5305\u542B\u975E\u6CD5\u63A7\u5236\u5B57\u7B26");
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function cmdQuote(value) {
+  if (/[\r\n\0"]/g.test(value)) throw invalid2("CLI \u542F\u52A8\u8DEF\u5F84\u5305\u542B\u975E\u6CD5\u63A7\u5236\u5B57\u7B26");
+  return `"${value.replace(/%/g, "%%")}"`;
+}
+function preparedFile(filePath, content, mode) {
+  return { path: filePath, content, bytes: content.length, sha256: sha2562(content), mode };
+}
+async function sha256File(file) {
+  const hash = createHash2("sha256");
+  await new Promise((resolve3, reject) => {
+    const stream = createReadStream(file);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", resolve3);
+  });
+  return hash.digest("hex");
+}
+function sha2562(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function invalid2(message) {
+  return new CliError15({ code: CliErrorCode14.INVALID_ARGUMENT, message });
+}
+
+// src/commands/skills.ts
 var SKILLS_STATE_FILE = ".hcm-skills.json";
-function sha256(text) {
-  return createHash("sha256").update(text, "utf8").digest("hex");
+function sha2563(text) {
+  return createHash3("sha256").update(text, "utf8").digest("hex");
 }
 async function resolveEndpoint(args) {
   if (args.endpoint) return args.endpoint.replace(/\/+$/, "");
@@ -4260,14 +5065,43 @@ async function resolveEndpoint(args) {
   const envName = resolveActiveEnv3({ envFlag: args.env }, process.env, g);
   const env2 = await loadEnv5(envName).catch(() => null);
   if (!env2?.endpoint) {
-    throw new CliError14({
-      code: CliErrorCode13.MISSING_FLAG,
+    throw new CliError16({
+      code: CliErrorCode15.MISSING_FLAG,
       message: "\u672A\u89E3\u6790\u5230 endpoint \u2014\u2014 \u4F20 --endpoint <url>\uFF0C\u6216\u5148 `hcm env add <name> --endpoint <url>`\u3002\uFF08\u6280\u80FD\u5E93\u514D\u8BA4\u8BC1\uFF0C\u4E0D\u9700\u8981\u5148 login\uFF09"
     });
   }
   return env2.endpoint.replace(/\/+$/, "");
 }
-async function exists(target) {
+function normalizeEndpoint2(endpoint) {
+  return endpoint.replace(/\/+$/, "");
+}
+function decideTrackedEndpoint(options) {
+  const { explicit } = options;
+  const current = options.current ? normalizeEndpoint2(options.current) : void 0;
+  const recorded = options.recorded ? normalizeEndpoint2(options.recorded) : void 0;
+  if (explicit) {
+    if (!current) throw invalid3("\u672A\u89E3\u6790\u5230 endpoint \u2014\u2014 \u4F20 --endpoint <url>\uFF0C\u6216\u7528 --env <name> \u6307\u4E00\u4E2A\u914D\u597D\u7684\u73AF\u5883");
+    return current;
+  }
+  if (!recorded) {
+    if (!current) {
+      throw new CliError16({
+        code: CliErrorCode15.MISSING_FLAG,
+        message: "\u672A\u89E3\u6790\u5230 endpoint \u2014\u2014 \u4F20 --endpoint <url>\uFF0C\u6216\u5148 `hcm env add <name> --endpoint <url>`\u3002\uFF08\u6280\u80FD\u5E93\u514D\u8BA4\u8BC1\uFF0C\u4E0D\u9700\u8981\u5148 login\uFF09"
+      });
+    }
+    return current;
+  }
+  if (!current || current === recorded) return recorded;
+  throw invalid3(
+    `\u8FD9\u4E2A\u76EE\u5F55\u7684\u6280\u80FD\u88C5\u81EA ${recorded}\uFF0C\u5F53\u524D env \u6307\u5411 ${current} \u2014\u2014 \u4E0D\u662F\u540C\u4E00\u4E2A\u73AF\u5883\u3002
+\u6280\u80FD\u968F\u4EA7\u54C1\u7248\u672C\u8D70\uFF0C\u8DE8\u73AF\u5883\u5347\u7EA7\u4F1A\u62FF\u53E6\u4E00\u4E2A\u73AF\u5883\u7684\u7248\u672C\u76D6\u6389\u73B0\u5728\u8FD9\u4EFD\uFF0C\u4E14\u4E0D\u4F1A\u6709\u4EFB\u4F55\u63D0\u793A\u3002
+\u660E\u8BF4\u8981\u54EA\u4E2A\uFF1A
+  \xB7 \u7EE7\u7EED\u8DDF ${recorded}    \u2192  \u52A0 --endpoint ${recorded}
+  \xB7 \u6539\u8DDF\u5F53\u524D\u8FD9\u4E2A           \u2192  \u52A0 --endpoint ${current}\uFF08\u6765\u6E90\u4F1A\u6539\u6210\u5B83\uFF0C\u4E4B\u540E\u4E0D\u7528\u518D\u5E26\uFF09`
+  );
+}
+async function exists2(target) {
   try {
     await fsp.stat(target);
     return true;
@@ -4276,25 +5110,25 @@ async function exists(target) {
   }
 }
 async function detectTarget(cwd) {
-  if (await exists(path2.join(cwd, ".claude"))) return "claude";
-  if (await exists(path2.join(cwd, "AGENTS.md"))) return "codex";
-  if (await exists(path2.join(cwd, ".codex"))) return "codex";
+  if (await exists2(path4.join(cwd, ".claude"))) return "claude";
+  if (await exists2(path4.join(cwd, "AGENTS.md"))) return "codex";
+  if (await exists2(path4.join(cwd, ".codex"))) return "codex";
   return void 0;
 }
 async function resolveInstallLayout(args, cwd = process.cwd()) {
   const requested = args.target && args.target !== "auto" ? args.target : void 0;
   const target = requested ?? await detectTarget(cwd) ?? "claude";
   if (target === "codex") {
-    const root = args.global ? path2.join(os2.homedir(), ".codex") : cwd;
+    const root = args.global ? path4.join(os2.homedir(), ".codex") : cwd;
     return {
       target,
-      baseDir: args.dir ? path2.resolve(args.dir) : path2.join(root, "hcm-skills"),
-      agentsFile: path2.join(root, "AGENTS.md")
+      baseDir: args.dir ? path4.resolve(args.dir) : path4.join(root, "hcm-skills"),
+      agentsFile: path4.join(root, "AGENTS.md")
     };
   }
   return {
     target,
-    baseDir: args.dir ? path2.resolve(args.dir) : args.global ? path2.join(os2.homedir(), ".claude", "skills") : path2.join(cwd, ".claude", "skills")
+    baseDir: args.dir ? path4.resolve(args.dir) : args.global ? path4.join(os2.homedir(), ".claude", "skills") : path4.join(cwd, ".claude", "skills")
   };
 }
 async function chironClient(args) {
@@ -4397,7 +5231,7 @@ async function listInstalledSkills(keyword, args) {
       process.stdout.write(formatObject13({ baseDir: layout.baseDir, target: layout.target, all: false, skills: [] }, { format: fmt }) + "\n");
       process.exit(0);
     }
-    process.stdout.write(`${path2.join(layout.baseDir, SKILLS_STATE_FILE)} \u4E0D\u5B58\u5728\u6216\u4E3A\u7A7A \u2014\u2014 \u8FD9\u4E2A\u76EE\u5F55\u4E0B\u8FD8\u6CA1\u7528\u672C CLI \u88C5\u8FC7\u6280\u80FD\u3002
+    process.stdout.write(`${path4.join(layout.baseDir, SKILLS_STATE_FILE)} \u4E0D\u5B58\u5728\u6216\u4E3A\u7A7A \u2014\u2014 \u8FD9\u4E2A\u76EE\u5F55\u4E0B\u8FD8\u6CA1\u7528\u672C CLI \u88C5\u8FC7\u6280\u80FD\u3002
 `);
     process.stdout.write("  \u88C5\u5168\u90E8\uFF1Ahcm skills install --all\n");
     process.exit(0);
@@ -4416,7 +5250,7 @@ async function listInstalledSkills(keyword, args) {
       direct: record.direct,
       installedAt: record.installedAt,
       // 三种状态互斥：文件没了 / 本地改过 / 和装的时候一致
-      status: markdown === void 0 ? "missing" : sha256(markdown) !== record.sha256 ? "locally-modified" : "installed"
+      status: markdown === void 0 ? "missing" : sha2563(markdown) !== record.sha256 ? "locally-modified" : "installed"
     });
   }
   const shown = keyword ? rows.filter((row) => row.id.includes(keyword) || row.title.includes(keyword)) : rows;
@@ -4470,12 +5304,74 @@ async function skillsShowCommand(id, args) {
     fail3(e, args);
   }
 }
+async function skillsSyncCommand(id, args) {
+  try {
+    assertSafeSkillId2(id);
+    if (args.target !== "workbuddy") {
+      throw invalid3(`sync --target \u5F53\u524D\u53EA\u652F\u6301 workbuddy\uFF0C\u6536\u5230 "${args.target ?? ""}"`);
+    }
+    if (!args.project?.trim()) throw invalid3("sync \u5FC5\u987B\u4F20 --project <path>");
+    const project = path4.resolve(args.project);
+    const runtime = await prepareWorkBuddyRuntime({
+      candidate: args.cli,
+      currentEntryHasRequiredCapabilities: !args.cli?.trim(),
+      forbiddenCandidatePaths: [
+        path4.join(project, ".hcm-delivery", "bin", "hcm"),
+        path4.join(project, ".hcm-delivery", "bin", "hcm.cmd")
+      ]
+    });
+    const connectionArgs = { endpoint: args.endpoint, env: args.env };
+    const { http, endpoint, base } = await chironClient(connectionArgs);
+    const catalog = await fetchSkillCatalog(http, base);
+    const documents = await prepareSkillDocuments(
+      catalog,
+      id,
+      async (skillId) => fetchSkillMarkdown(http, skillId, base),
+      async (skillId, relativePath) => fetchSkillFile(http, skillId, relativePath, base),
+      async (skillId, relativePath) => fetchSkillReference(http, skillId, relativePath, base)
+    );
+    const result2 = await syncWorkBuddyProject({
+      project,
+      endpoint,
+      catalog,
+      requestedSkill: id,
+      documents,
+      runtime
+    });
+    const fmt = args.output ?? "table";
+    if (fmt === "json" || fmt === "yaml") {
+      process.stdout.write(`${formatObject13(result2, { format: fmt })}
+`);
+    } else if (result2.changed) {
+      process.stdout.write(`\u2705 ${id} \u2192 ${result2.skillsDir}
+`);
+      process.stdout.write(`   \u95ED\u5305 ${result2.resolvedSkills.join(" \u2192 ")}
+`);
+      process.stdout.write(`   \u5165\u53E3 ${result2.runnerPath}
+`);
+      process.stdout.write(`   CLI \u80FD\u529B ${result2.capabilitiesSha256.slice(0, 12)}
+`);
+      process.stdout.write(`   \u9501 ${result2.lockPath}
+`);
+    } else {
+      process.stdout.write(`\u2713 ${id} \u5DF2\u662F\u5F53\u524D\u76EE\u6807\u5B9E\u4F8B\u7248\u672C\uFF0C\u65E0\u9700\u66F4\u65B0
+`);
+      process.stdout.write(`  \u5165\u53E3 ${result2.runnerPath}
+`);
+      process.stdout.write(`  \u9501 ${result2.lockPath}
+`);
+    }
+    process.exit(0);
+  } catch (e) {
+    fail3(e, { endpoint: args.endpoint, env: args.env });
+  }
+}
 async function skillsInstallCommand(id, args) {
   try {
     const all = Boolean(args.all);
-    if (all && id) throw invalid("`--all` \u662F\u88C5\u6574\u4E2A\u6280\u80FD\u5E93\uFF0C\u4E0D\u8981\u518D\u5E26\u6280\u80FD id\uFF1B\u53EA\u88C5\u4E00\u4E2A\u5C31\u53BB\u6389 --all");
-    if (!all && !id) throw invalid("\u8981\u88C5\u54EA\u4E2A\u6280\u80FD\uFF1F\u7ED9\u4E2A id\uFF08`hcm skills list` \u770B\u76EE\u5F55\uFF09\uFF0C\u6216\u7528 `--all` \u88C5\u5168\u90E8");
-    if (id) assertSafeSkillId(id);
+    if (all && id) throw invalid3("`--all` \u662F\u88C5\u6574\u4E2A\u6280\u80FD\u5E93\uFF0C\u4E0D\u8981\u518D\u5E26\u6280\u80FD id\uFF1B\u53EA\u88C5\u4E00\u4E2A\u5C31\u53BB\u6389 --all");
+    if (!all && !id) throw invalid3("\u8981\u88C5\u54EA\u4E2A\u6280\u80FD\uFF1F\u7ED9\u4E2A id\uFF08`hcm skills list` \u770B\u76EE\u5F55\uFF09\uFF0C\u6216\u7528 `--all` \u88C5\u5168\u90E8");
+    if (id) assertSafeSkillId2(id);
     const layout = await resolveInstallLayout(args);
     let documents;
     let requestedIds;
@@ -4483,7 +5379,7 @@ async function skillsInstallCommand(id, args) {
     let base;
     let manifest2;
     if (args.from) {
-      const root = path2.resolve(args.from);
+      const root = path4.resolve(args.from);
       requestedIds = all ? await listLocalSkillIds(root) : [id];
       const seen = /* @__PURE__ */ new Set();
       documents = [];
@@ -4495,12 +5391,17 @@ async function skillsInstallCommand(id, args) {
         }
       }
     } else {
-      const client3 = await chironClient(args);
+      const tracked = decideTrackedEndpoint({
+        explicit: Boolean(args.endpoint || args.env),
+        current: await resolveEndpoint(args).catch(() => void 0),
+        recorded: (await readSkillsState(layout.baseDir))?.endpoint
+      });
+      const client3 = await chironClient({ ...args, endpoint: tracked });
       endpoint = client3.endpoint;
       base = client3.base;
       manifest2 = await fetchSkillCatalog(client3.http, base);
-      const order = all ? resolveAllSkillsInstallOrder(manifest2) : resolveSkillInstallOrder(manifest2, id);
-      if (all && order.length === 0) throw invalid(`${endpoint} \u7684\u6280\u80FD\u76EE\u5F55\u662F\u7A7A\u7684\uFF0C\u6CA1\u6709\u53EF\u88C5\u7684\u6280\u80FD`);
+      const order = all ? resolveAllSkillsInstallOrder(manifest2) : resolveSkillInstallOrder2(manifest2, id);
+      if (all && order.length === 0) throw invalid3(`${endpoint} \u7684\u6280\u80FD\u76EE\u5F55\u662F\u7A7A\u7684\uFF0C\u6CA1\u6709\u53EF\u88C5\u7684\u6280\u80FD`);
       requestedIds = all ? order.map((skill) => skill.id) : [id];
       documents = await mapWithConcurrency(
         order,
@@ -4508,7 +5409,7 @@ async function skillsInstallCommand(id, args) {
         (skill) => fetchSkillDocument(client3.http, skill, endpoint, base)
       );
     }
-    const result = await installSkillDocuments(documents, requestedIds, layout.baseDir, Boolean(args.force), {
+    const result2 = await installSkillDocuments(documents, requestedIds, layout.baseDir, Boolean(args.force), {
       endpoint,
       base,
       target: layout.target,
@@ -4517,19 +5418,19 @@ async function skillsInstallCommand(id, args) {
     const agents = layout.agentsFile ? await syncAgentsIndex(layout, manifest2) : void 0;
     const fmt = args.output ?? "table";
     if (fmt === "json" || fmt === "yaml") {
-      process.stdout.write(formatObject13({ ...result, all, target_agent: layout.target, agentsFile: layout.agentsFile, agents }, { format: fmt }) + "\n");
+      process.stdout.write(formatObject13({ ...result2, all, target_agent: layout.target, agentsFile: layout.agentsFile, agents }, { format: fmt }) + "\n");
     } else {
-      const headline = all ? `\u2705 \u5168\u90E8 ${requestedIds.length} \u4E2A\u6280\u80FD \u2192 ${result.baseDir}` : `\u2705 ${id} \u2192 ${path2.join(result.baseDir, id, "SKILL.md")}`;
+      const headline = all ? `\u2705 \u5168\u90E8 ${requestedIds.length} \u4E2A\u6280\u80FD \u2192 ${result2.baseDir}` : `\u2705 ${id} \u2192 ${path4.join(result2.baseDir, id, "SKILL.md")}`;
       process.stdout.write(`${headline}
 `);
-      if (result.installed.length > 0) {
-        process.stdout.write(all ? `   \u65B0\u5199\u5165 ${result.installed.length} \u4E2A
-` : `   \u5DF2\u5B89\u88C5 ${result.installed.join(" \u2192 ")}
+      if (result2.installed.length > 0) {
+        process.stdout.write(all ? `   \u65B0\u5199\u5165 ${result2.installed.length} \u4E2A
+` : `   \u5DF2\u5B89\u88C5 ${result2.installed.join(" \u2192 ")}
 `);
       }
-      if (result.unchanged.length > 0) {
-        process.stdout.write(all ? `   \u5DF2\u662F\u8FD9\u4E00\u7248\u3001\u672A\u6539\u52A8 ${result.unchanged.length} \u4E2A
-` : `   \u5DF2\u5B58\u5728\u4E14\u7248\u672C\u4E00\u81F4 ${result.unchanged.join(", ")}
+      if (result2.unchanged.length > 0) {
+        process.stdout.write(all ? `   \u5DF2\u662F\u8FD9\u4E00\u7248\u3001\u672A\u6539\u52A8 ${result2.unchanged.length} \u4E2A
+` : `   \u5DF2\u5B58\u5728\u4E14\u7248\u672C\u4E00\u81F4 ${result2.unchanged.join(", ")}
 `);
       }
       const referenceCount = documents.reduce((n, d) => n + (d.references?.length ?? 0), 0);
@@ -4541,7 +5442,7 @@ async function skillsInstallCommand(id, args) {
         process.stdout.write(`   \u5DF2${agents === "created" ? "\u521B\u5EFA" : "\u66F4\u65B0"} ${layout.agentsFile} \u91CC\u7684\u6280\u80FD\u7D22\u5F15\uFF08Codex \u8BFB\u8FD9\u91CC\uFF09
 `);
       }
-      process.stdout.write(`   \u6765\u6E90 ${endpoint ?? path2.resolve(args.from)}
+      process.stdout.write(`   \u6765\u6E90 ${endpoint ?? path4.resolve(args.from)}
 `);
       process.stdout.write(all ? "   \u5DF2\u8BB0\u4E3A\u300C\u8DDF\u968F\u5168\u96C6\u300D\uFF1A\u4EE5\u540E\u8DD1 hcm skills update\uFF0C\u4EA7\u54C1\u65B0\u589E\u7684\u6280\u80FD\u4F1A\u81EA\u52A8\u8865\u4E0A\n" : "   \u4EA7\u54C1\u66F4\u65B0\u540E\u8DD1 hcm skills update \u5347\u7EA7\n");
     }
@@ -4569,18 +5470,18 @@ async function listLocalSkillIds(root) {
   try {
     entries = await fsp.readdir(root, { withFileTypes: true });
   } catch {
-    throw invalid(`\u8BFB\u4E0D\u5230\u672C\u5730\u6280\u80FD\u76EE\u5F55\uFF1A${root}`);
+    throw invalid3(`\u8BFB\u4E0D\u5230\u672C\u5730\u6280\u80FD\u76EE\u5F55\uFF1A${root}`);
   }
   const ids = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    if (await exists(path2.join(root, entry.name, "SKILL.md"))) ids.push(entry.name);
+    if (await exists2(path4.join(root, entry.name, "SKILL.md"))) ids.push(entry.name);
   }
-  if (ids.length === 0) throw invalid(`\u672C\u5730\u76EE\u5F55\u91CC\u6CA1\u6709\u4EFB\u4F55 <id>/SKILL.md\uFF1A${root}`);
+  if (ids.length === 0) throw invalid3(`\u672C\u5730\u76EE\u5F55\u91CC\u6CA1\u6709\u4EFB\u4F55 <id>/SKILL.md\uFF1A${root}`);
   return ids.sort();
 }
 async function fetchSkillDocument(http, skill, endpoint, base) {
-  const relatives = normalizeReferences(skill.references, skill.id);
+  const relatives = normalizeReferences2(skill.references, skill.id);
   const references = await Promise.all(relatives.map(async (relative2) => ({
     path: relative2,
     content: await fetchSkillReference(http, skill.id, relative2, base)
@@ -4600,23 +5501,23 @@ async function syncAgentsIndex(layout, manifest2) {
   for (const category of manifest2?.categories ?? []) {
     for (const skill of category.skills ?? []) catalog.set(skill.id, skill);
   }
-  const agentsDir = path2.dirname(layout.agentsFile);
+  const agentsDir = path4.dirname(layout.agentsFile);
   const entries = Object.keys(state.skills).sort().map((id) => {
     const known = catalog.get(id);
-    const absolute = path2.join(layout.baseDir, id, "SKILL.md");
-    let relative2 = path2.relative(agentsDir, absolute);
+    const absolute = path4.join(layout.baseDir, id, "SKILL.md");
+    let relative2 = path4.relative(agentsDir, absolute);
     if (!relative2.startsWith(".")) relative2 = `./${relative2}`;
     return {
       id,
       title: known?.title ?? id,
       description: known?.description ?? "",
-      relativePath: relative2.split(path2.sep).join("/")
+      relativePath: relative2.split(path4.sep).join("/")
     };
   });
   return upsertAgentsBlock(layout.agentsFile, renderAgentsBlock(entries));
 }
 async function resolveLocalSkillDocuments(sourceRoot, targetId) {
-  assertSafeSkillId(targetId);
+  assertSafeSkillId2(targetId);
   const state = /* @__PURE__ */ new Map();
   const pathStack = [];
   const order = [];
@@ -4625,27 +5526,27 @@ async function resolveLocalSkillDocuments(sourceRoot, targetId) {
     if (current === "done") return;
     if (current === "visiting") {
       const start = pathStack.indexOf(id);
-      throw invalid(`\u6280\u80FD\u4F9D\u8D56\u5B58\u5728\u73AF: ${[...pathStack.slice(Math.max(0, start)), id].join(" -> ")}`);
+      throw invalid3(`\u6280\u80FD\u4F9D\u8D56\u5B58\u5728\u73AF: ${[...pathStack.slice(Math.max(0, start)), id].join(" -> ")}`);
     }
-    assertSafeSkillId(id);
-    const local = path2.join(sourceRoot, id, "SKILL.md");
+    assertSafeSkillId2(id);
+    const local = path4.join(sourceRoot, id, "SKILL.md");
     let markdown;
     try {
       markdown = await fsp.readFile(local, "utf8");
     } catch (cause) {
       if (cause?.code === "ENOENT") {
-        throw invalid(requiredBy ? `\u672C\u5730\u6280\u80FD ${requiredBy} \u4F9D\u8D56\u4E0D\u5B58\u5728: ${id}\uFF08${local}\uFF09` : `\u672C\u5730\u76EE\u5F55\u91CC\u6CA1\u6709 ${id}/SKILL.md\uFF1A${path2.join(sourceRoot, id)}`);
+        throw invalid3(requiredBy ? `\u672C\u5730\u6280\u80FD ${requiredBy} \u4F9D\u8D56\u4E0D\u5B58\u5728: ${id}\uFF08${local}\uFF09` : `\u672C\u5730\u76EE\u5F55\u91CC\u6CA1\u6709 ${id}/SKILL.md\uFF1A${path4.join(sourceRoot, id)}`);
       }
       throw cause;
     }
-    if (!markdown.trim()) throw invalid(`\u6280\u80FD ${id} \u5185\u5BB9\u4E3A\u7A7A`);
+    if (!markdown.trim()) throw invalid3(`\u6280\u80FD ${id} \u5185\u5BB9\u4E3A\u7A7A`);
     state.set(id, "visiting");
     pathStack.push(id);
     const document = {
       id,
       markdown,
       source: local,
-      references: await readLocalReferences(path2.join(sourceRoot, id))
+      references: await readLocalReferences(path4.join(sourceRoot, id))
     };
     for (const required of parseSkillRequirements(markdown, id)) {
       await visit(required, id);
@@ -4659,7 +5560,7 @@ async function resolveLocalSkillDocuments(sourceRoot, targetId) {
 }
 async function readSkillsState(baseDir) {
   try {
-    const raw = await fsp.readFile(path2.join(baseDir, SKILLS_STATE_FILE), "utf8");
+    const raw = await fsp.readFile(path4.join(baseDir, SKILLS_STATE_FILE), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || !parsed.skills) return void 0;
     return parsed;
@@ -4669,7 +5570,7 @@ async function readSkillsState(baseDir) {
 }
 async function writeSkillsState(baseDir, state) {
   await fsp.mkdir(baseDir, { recursive: true });
-  const file = path2.join(baseDir, SKILLS_STATE_FILE);
+  const file = path4.join(baseDir, SKILLS_STATE_FILE);
   const temp = `${file}.${process.pid}.tmp`;
   await fsp.writeFile(temp, JSON.stringify(state, null, 2) + "\n", "utf8");
   await fsp.rename(temp, file);
@@ -4698,7 +5599,7 @@ async function upsertAgentsBlock(agentsFile, block) {
     existing = await fsp.readFile(agentsFile, "utf8");
   } catch (cause) {
     if (cause?.code !== "ENOENT") throw cause;
-    await fsp.mkdir(path2.dirname(agentsFile), { recursive: true });
+    await fsp.mkdir(path4.dirname(agentsFile), { recursive: true });
     await fsp.writeFile(agentsFile, block + "\n", "utf8");
     return "created";
   }
@@ -4714,22 +5615,22 @@ async function upsertAgentsBlock(agentsFile, block) {
   return "appended";
 }
 async function installSkillDocuments(documents, requestedIds, baseDir, force, meta2) {
-  if (requestedIds.length === 0) throw invalid("\u6CA1\u6709\u6307\u5B9A\u8981\u88C5\u7684\u6280\u80FD");
-  for (const id of requestedIds) assertSafeSkillId(id);
+  if (requestedIds.length === 0) throw invalid3("\u6CA1\u6709\u6307\u5B9A\u8981\u88C5\u7684\u6280\u80FD");
+  for (const id of requestedIds) assertSafeSkillId2(id);
   const seen = /* @__PURE__ */ new Set();
   const candidates = documents.map((document) => {
-    assertSafeSkillId(document.id);
-    if (seen.has(document.id)) throw invalid(`\u5B89\u88C5\u95ED\u5305\u5305\u542B\u91CD\u590D\u6280\u80FD: ${document.id}`);
+    assertSafeSkillId2(document.id);
+    if (seen.has(document.id)) throw invalid3(`\u5B89\u88C5\u95ED\u5305\u5305\u542B\u91CD\u590D\u6280\u80FD: ${document.id}`);
     seen.add(document.id);
-    if (!document.markdown.trim()) throw invalid(`\u6280\u80FD ${document.id} \u5185\u5BB9\u4E3A\u7A7A`);
+    if (!document.markdown.trim()) throw invalid3(`\u6280\u80FD ${document.id} \u5185\u5BB9\u4E3A\u7A7A`);
     return {
       ...document,
-      target: path2.join(baseDir, document.id, "SKILL.md"),
+      target: path4.join(baseDir, document.id, "SKILL.md"),
       bytes: Buffer.byteLength(document.markdown)
     };
   });
   for (const id of requestedIds) {
-    if (!seen.has(id)) throw invalid(`\u5B89\u88C5\u95ED\u5305\u4E0D\u5305\u542B\u76EE\u6807\u6280\u80FD: ${id}`);
+    if (!seen.has(id)) throw invalid3(`\u5B89\u88C5\u95ED\u5305\u4E0D\u5305\u542B\u76EE\u6807\u6280\u80FD: ${id}`);
   }
   const unchanged = /* @__PURE__ */ new Set();
   for (const candidate of candidates) {
@@ -4740,7 +5641,7 @@ async function installSkillDocuments(documents, requestedIds, baseDir, force, me
       unchanged.add(candidate.id);
       continue;
     }
-    throw invalid(
+    throw invalid3(
       `${candidate.target} \u5DF2\u5B58\u5728\uFF0C\u4E14\u548C\u76EE\u6807\u73AF\u5883\u8FD9\u4E00\u7248\u4E0D\u4E00\u81F4\u3002\u7528 --force \u8986\u76D6\uFF08\u4F1A\u4E22\u6389\u672C\u5730\u6539\u52A8\uFF09\uFF0C\u6216 --dir <path> \u88C5\u5230\u522B\u5904\uFF1B\u53EA\u60F3\u8DDF\u4E0A\u4EA7\u54C1\u7248\u672C\u7528 hcm skills update`
     );
   }
@@ -4775,7 +5676,7 @@ async function sameOnDisk(baseDir, candidate) {
   return true;
 }
 async function readLocalReferences(skillDir) {
-  const root = path2.join(skillDir, "references");
+  const root = path4.join(skillDir, "references");
   const out = [];
   const walk = async (dir, prefix) => {
     let items;
@@ -4788,12 +5689,12 @@ async function readLocalReferences(skillDir) {
     for (const item of items.sort((a, b) => a.name.localeCompare(b.name))) {
       const relative2 = prefix ? `${prefix}/${item.name}` : item.name;
       if (item.isDirectory()) {
-        await walk(path2.join(dir, item.name), relative2);
+        await walk(path4.join(dir, item.name), relative2);
         continue;
       }
       if (!item.isFile()) continue;
       assertSafeReferencePath(relative2);
-      out.push({ path: relative2, content: await fsp.readFile(path2.join(dir, item.name), "utf8") });
+      out.push({ path: relative2, content: await fsp.readFile(path4.join(dir, item.name), "utf8") });
     }
   };
   await walk(root, "");
@@ -4803,15 +5704,15 @@ async function writeSkillDocuments(documents, baseDir) {
   const staged = [];
   try {
     for (const document of documents) {
-      const target = path2.join(baseDir, document.id, "SKILL.md");
-      await fsp.mkdir(path2.dirname(target), { recursive: true });
-      const temp = path2.join(path2.dirname(target), `.SKILL.md.${process.pid}.${Date.now()}.tmp`);
+      const target = path4.join(baseDir, document.id, "SKILL.md");
+      await fsp.mkdir(path4.dirname(target), { recursive: true });
+      const temp = path4.join(path4.dirname(target), `.SKILL.md.${process.pid}.${Date.now()}.tmp`);
       await fsp.writeFile(temp, document.markdown, "utf8");
       staged.push({ temp, target });
       for (const reference of document.references ?? []) {
         assertSafeReferencePath(reference.path);
-        const referenceTarget = path2.join(baseDir, document.id, "references", reference.path);
-        await fsp.mkdir(path2.dirname(referenceTarget), { recursive: true });
+        const referenceTarget = path4.join(baseDir, document.id, "references", reference.path);
+        await fsp.mkdir(path4.dirname(referenceTarget), { recursive: true });
         const referenceTemp = `${referenceTarget}.${process.pid}.${Date.now()}.tmp`;
         await fsp.writeFile(referenceTemp, reference.content, "utf8");
         staged.push({ temp: referenceTemp, target: referenceTarget });
@@ -4840,24 +5741,24 @@ async function recordInstalled(baseDir, documents, meta2) {
     const previous = state.skills[document.id];
     state.skills[document.id] = {
       source: document.source,
-      sha256: sha256(document.markdown),
+      sha256: sha2563(document.markdown),
       installedAt: meta2.keepInstalledAt?.has(document.id) && previous ? previous.installedAt : state.updatedAt,
       // 已经是直接安装的，不因为这次作为依赖被带进来就降级
       direct: meta2.directIds.has(document.id) || Boolean(previous?.direct),
       references: Object.fromEntries(
-        (document.references ?? []).map((reference) => [reference.path, sha256(reference.content)])
+        (document.references ?? []).map((reference) => [reference.path, sha2563(reference.content)])
       )
     };
   }
   await writeSkillsState(baseDir, state);
   return state;
 }
-function invalid(message) {
-  return new CliError14({ code: CliErrorCode13.INVALID_ARGUMENT, message });
+function invalid3(message) {
+  return new CliError16({ code: CliErrorCode15.INVALID_ARGUMENT, message });
 }
 async function readInstalled(baseDir, id) {
   try {
-    return await fsp.readFile(path2.join(baseDir, id, "SKILL.md"), "utf8");
+    return await fsp.readFile(path4.join(baseDir, id, "SKILL.md"), "utf8");
   } catch (cause) {
     if (cause?.code === "ENOENT") return void 0;
     throw cause;
@@ -4865,7 +5766,7 @@ async function readInstalled(baseDir, id) {
 }
 async function readInstalledReference(baseDir, id, relative2) {
   try {
-    return await fsp.readFile(path2.join(baseDir, id, "references", relative2), "utf8");
+    return await fsp.readFile(path4.join(baseDir, id, "references", relative2), "utf8");
   } catch (cause) {
     if (cause?.code === "ENOENT") return void 0;
     throw cause;
@@ -4881,7 +5782,7 @@ async function planSkillUpdate(options) {
   const closure = /* @__PURE__ */ new Map();
   for (const id of wanted.sort()) {
     try {
-      for (const skill of resolveSkillInstallOrder(manifest2, id)) {
+      for (const skill of resolveSkillInstallOrder2(manifest2, id)) {
         if (!closure.has(skill.id)) closure.set(skill.id, skill);
       }
     } catch {
@@ -4908,12 +5809,12 @@ async function planSkillUpdate(options) {
     const remote = await fetchDocument(skill);
     const remoteReferences = remote.references ?? [];
     let differsFromRemote = remote.markdown !== onDisk;
-    let editedLocally = record !== void 0 && sha256(onDisk) !== record.sha256;
+    let editedLocally = record !== void 0 && sha2563(onDisk) !== record.sha256;
     for (const reference of remoteReferences) {
       const installed = await readInstalledReference(baseDir, skill.id, reference.path);
       if (installed !== reference.content) differsFromRemote = true;
       const recordedSha = record?.references?.[reference.path];
-      if (installed !== void 0 && recordedSha && sha256(installed) !== recordedSha) editedLocally = true;
+      if (installed !== void 0 && recordedSha && sha2563(installed) !== recordedSha) editedLocally = true;
     }
     if (!differsFromRemote) {
       entries.push({ id: skill.id, status: "unchanged" });
@@ -4949,14 +5850,15 @@ async function skillsUpdateCommand(args) {
     const layout = await resolveInstallLayout(args);
     const state = await readSkillsState(layout.baseDir);
     if (!state || Object.keys(state.skills).length === 0) {
-      throw new CliError14({
-        code: CliErrorCode13.INVALID_ARGUMENT,
-        message: `${path2.join(layout.baseDir, SKILLS_STATE_FILE)} \u4E0D\u5B58\u5728\u6216\u4E3A\u7A7A \u2014\u2014 \u8FD9\u4E2A\u76EE\u5F55\u4E0B\u8FD8\u6CA1\u6709\u7528\u672C CLI \u88C5\u8FC7\u6280\u80FD\u3002\u5148 \`hcm skills install <id>\`\uFF1B\u5982\u679C\u6280\u80FD\u662F\u624B\u5DE5\u62F7\u8FDB\u6765\u7684\uFF0C\u91CD\u88C5\u4E00\u6B21\u5373\u53EF\u63A5\u7BA1\u5347\u7EA7\u3002`
+      throw new CliError16({
+        code: CliErrorCode15.INVALID_ARGUMENT,
+        message: `${path4.join(layout.baseDir, SKILLS_STATE_FILE)} \u4E0D\u5B58\u5728\u6216\u4E3A\u7A7A \u2014\u2014 \u8FD9\u4E2A\u76EE\u5F55\u4E0B\u8FD8\u6CA1\u6709\u7528\u672C CLI \u88C5\u8FC7\u6280\u80FD\u3002\u5148 \`hcm skills install <id>\`\uFF1B\u5982\u679C\u6280\u80FD\u662F\u624B\u5DE5\u62F7\u8FDB\u6765\u7684\uFF0C\u91CD\u88C5\u4E00\u6B21\u5373\u53EF\u63A5\u7BA1\u5347\u7EA7\u3002`
       });
     }
-    const endpoint = args.endpoint ? args.endpoint.replace(/\/+$/, "") : await resolveEndpoint(args).catch((e) => {
-      if (state.endpoint) return state.endpoint;
-      throw e;
+    const endpoint = decideTrackedEndpoint({
+      explicit: Boolean(args.endpoint || args.env),
+      current: await resolveEndpoint(args).catch(() => void 0),
+      recorded: state.endpoint
     });
     const { http, base } = await chironClient({ ...args, endpoint });
     const manifest2 = await fetchSkillCatalog(http, base);
@@ -5034,8 +5936,8 @@ import {
   loadEnv as loadEnv6,
   loadGlobalConfig as loadGlobalConfig7,
   resolveActiveEnv as resolveActiveEnv4,
-  CliError as CliError15,
-  CliErrorCode as CliErrorCode14
+  CliError as CliError17,
+  CliErrorCode as CliErrorCode16
 } from "@hcmai/sdk";
 init_exit();
 async function resolveBootstrapKey(args, stdinTaken) {
@@ -5043,8 +5945,8 @@ async function resolveBootstrapKey(args, stdinTaken) {
   if (fromEnv) return fromEnv;
   if (args.bootstrapKeyStdin) {
     if (stdinTaken) {
-      throw new CliError15({
-        code: CliErrorCode14.INVALID_ARGUMENT,
+      throw new CliError17({
+        code: CliErrorCode16.INVALID_ARGUMENT,
         message: "--bootstrap-key-stdin \u4E0E --admin-password-stdin \u4E0D\u80FD\u540C\u65F6\u7528\uFF08stdin \u53EA\u6709\u4E00\u8DEF\uFF09\uFF1B\u628A\u5176\u4E2D\u4E00\u4E2A\u6539\u8D70 HCM_BOOTSTRAP_KEY \u73AF\u5883\u53D8\u91CF\u6216\u4EA4\u4E92\u8F93\u5165"
       });
     }
@@ -5074,8 +5976,8 @@ async function resolveEndpoint2(args) {
   const envName = resolveActiveEnv4({ envFlag: args.env }, process.env, g);
   const env2 = await loadEnv6(envName).catch(() => null);
   if (!env2?.endpoint) {
-    throw new CliError15({
-      code: CliErrorCode14.MISSING_FLAG,
+    throw new CliError17({
+      code: CliErrorCode16.MISSING_FLAG,
       message: "\u672A\u89E3\u6790\u5230 endpoint \u2014\u2014 \u4F20 --endpoint <url>\uFF0C\u6216\u5148 `hcm env add <name> --endpoint <url>`"
     });
   }
@@ -5084,8 +5986,8 @@ async function resolveEndpoint2(args) {
 async function tenantBootstrapCommand(args) {
   try {
     if (!args.tenantId || !args.adminUsername) {
-      throw new CliError15({
-        code: CliErrorCode14.MISSING_FLAG,
+      throw new CliError17({
+        code: CliErrorCode16.MISSING_FLAG,
         message: "--tenant-id \u4E0E --admin-username \u5FC5\u586B"
       });
     }
@@ -5107,7 +6009,7 @@ async function tenantBootstrapCommand(args) {
       onRefresh: async () => {
       }
     });
-    const result = await bootstrapTenant(http, key, {
+    const result2 = await bootstrapTenant(http, key, {
       tenantId: args.tenantId,
       adminUsername: args.adminUsername,
       adminPassword: pwd,
@@ -5116,12 +6018,12 @@ async function tenantBootstrapCommand(args) {
     const fmt = args.output ?? "json";
     if (fmt !== "json") {
       process.stdout.write(
-        `\u2705 \u79DF\u6237 ${result.tenantId} \u5DF2\u5F00\u901A\uFF08adminUserId ${result.adminUserId ?? "-"}\uFF09
+        `\u2705 \u79DF\u6237 ${result2.tenantId} \u5DF2\u5F00\u901A\uFF08adminUserId ${result2.adminUserId ?? "-"}\uFF09
    \u4E0B\u4E00\u6B65\uFF1Ahcm env add <name> --endpoint ${endpoint} && hcm login --env <name>
 `
       );
     }
-    process.stdout.write(formatObject14(result, { format: fmt }) + "\n");
+    process.stdout.write(formatObject14(result2, { format: fmt }) + "\n");
     process.exit(0);
   } catch (e) {
     const err = e;
@@ -5145,8 +6047,8 @@ import {
   getTenantMeta,
   saveTenantMeta,
   deleteTenantMeta,
-  CliError as CliError16,
-  CliErrorCode as CliErrorCode15
+  CliError as CliError18,
+  CliErrorCode as CliErrorCode17
 } from "@hcmai/sdk";
 init_exit();
 init_auth_guard();
@@ -5182,21 +6084,21 @@ async function metaListCommand(args) {
     fail4(e, args);
   }
 }
-async function metaGetCommand(path4, args) {
+async function metaGetCommand(path7, args) {
   try {
     const c = await client2(args);
-    const content = await getTenantMeta(c.raw(), path4);
+    const content = await getTenantMeta(c.raw(), path7);
     process.stdout.write(content.endsWith("\n") ? content : content + "\n");
     process.exit(0);
   } catch (e) {
     fail4(e, args);
   }
 }
-async function metaSetCommand(path4, args) {
+async function metaSetCommand(path7, args) {
   try {
     if (!args.file) {
-      throw new CliError16({
-        code: CliErrorCode15.MISSING_FLAG,
+      throw new CliError18({
+        code: CliErrorCode17.MISSING_FLAG,
         message: "--file <path> \u5FC5\u586B\uFF08\u4ECE\u6587\u4EF6\u8BFB\u53D6 meta \u539F\u6587\uFF1B\u7528 - \u8868\u793A stdin\uFF09"
       });
     }
@@ -5209,7 +6111,7 @@ async function metaSetCommand(path4, args) {
     }) : await fsp2.readFile(args.file, "utf8");
     if (args.dryRun) {
       process.stdout.write(
-        `[dry-run] \u5C06\u5199\u5165 ${path4}\uFF08${Buffer.byteLength(content)} B\uFF09\u2014\u2014\u672A\u5B9E\u9645\u5199\u5165
+        `[dry-run] \u5C06\u5199\u5165 ${path7}\uFF08${Buffer.byteLength(content)} B\uFF09\u2014\u2014\u672A\u5B9E\u9645\u5199\u5165
 ---
 ${content}
 `
@@ -5217,35 +6119,35 @@ ${content}
       process.exit(0);
     }
     const c = await client2(args);
-    const result = await saveTenantMeta(c.raw(), path4, content);
+    const result2 = await saveTenantMeta(c.raw(), path7, content);
     const fmt = args.output ?? "json";
     if (fmt !== "json") {
-      process.stdout.write(`\u2705 \u5DF2\u5199\u5165 ${path4}
+      process.stdout.write(`\u2705 \u5DF2\u5199\u5165 ${path7}
    \u8BB0\u5F97\u6E05\u7F13\u5B58\uFF1Ahcm cache clear-meta <Model>
 `);
     }
-    process.stdout.write(formatObject15(result, { format: fmt }) + "\n");
+    process.stdout.write(formatObject15(result2, { format: fmt }) + "\n");
     process.exit(0);
   } catch (e) {
     if (e?.code === "ENOENT") exitWithError(new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${args.file}`));
     fail4(e, args);
   }
 }
-async function metaDeleteCommand(path4, args) {
+async function metaDeleteCommand(path7, args) {
   try {
     if (!args.yes) {
-      const ok = await promptConfirm(`\u5C06\u5220\u9664\u5143\u6570\u636E ${path4}\uFF0C\u6B64\u64CD\u4F5C\u4E0D\u53EF\u9006\u3002\u7EE7\u7EED\uFF1F`);
+      const ok = await promptConfirm(`\u5C06\u5220\u9664\u5143\u6570\u636E ${path7}\uFF0C\u6B64\u64CD\u4F5C\u4E0D\u53EF\u9006\u3002\u7EE7\u7EED\uFF1F`);
       if (!ok) {
         process.stderr.write("\u5DF2\u53D6\u6D88\n");
         process.exit(1);
       }
     }
     const c = await client2(args);
-    const result = await deleteTenantMeta(c.raw(), path4);
+    const result2 = await deleteTenantMeta(c.raw(), path7);
     const fmt = args.output ?? "json";
-    if (fmt !== "json") process.stdout.write(`\u{1F5D1}\uFE0F  \u5DF2\u5220\u9664 ${path4}
+    if (fmt !== "json") process.stdout.write(`\u{1F5D1}\uFE0F  \u5DF2\u5220\u9664 ${path7}
 `);
-    process.stdout.write(formatObject15(result, { format: fmt }) + "\n");
+    process.stdout.write(formatObject15(result2, { format: fmt }) + "\n");
     process.exit(0);
   } catch (e) {
     fail4(e, args);
@@ -5256,8 +6158,8 @@ async function metaDeleteCommand(path4, args) {
 init_exit();
 init_auth_guard();
 import * as crypto from "crypto";
-import * as fs4 from "fs/promises";
-import * as path3 from "path";
+import * as fs6 from "fs/promises";
+import * as path5 from "path";
 import {
   buildMiniPreviewTargets,
   buildMiniVerifyAgentReport,
@@ -5326,7 +6228,7 @@ async function workspaceListCommand(args) {
   try {
     const client3 = HcmClient16.fromAuthContext(await getActiveAuthContextFromCli(args));
     const limit = parsePositiveInt3(args.limit, 50, "--limit");
-    const result = await client3.query("TenantExtensionWorkspace", {
+    const result2 = await client3.query("TenantExtensionWorkspace", {
       keyword: args.keyword,
       fields: [
         "workspaceKey",
@@ -5341,7 +6243,7 @@ async function workspaceListCommand(args) {
       sort: [{ field: "devModeEnabled", desc: true }, { field: "updateTime", desc: true }],
       limit
     });
-    writeWorkspaceListResult(result.rows, args.output ?? "table", result.total);
+    writeWorkspaceListResult(result2.rows, args.output ?? "table", result2.total);
     process.exit(0);
   } catch (e) {
     exitWorkspaceError(e, args.env ?? args.profile);
@@ -5355,12 +6257,12 @@ async function workspaceActiveCommand(args) {
       fallbackEnv: localContext?.profile
     });
     const client3 = HcmClient16.fromAuthContext(ctx);
-    const result = await client3.query("TenantExtensionWorkspace", {
+    const result2 = await client3.query("TenantExtensionWorkspace", {
       filter: { devModeEnabled: true },
       fields: ["workspaceKey", "devModeEnabled"],
       limit: 1
     });
-    const activeWorkspaceKey = optionalText(result.rows[0]?.workspaceKey) ?? null;
+    const activeWorkspaceKey = optionalText(result2.rows[0]?.workspaceKey) ?? null;
     const view = {
       activeWorkspaceKey,
       localWorkspaceKey: localContext?.workspaceKey ?? null,
@@ -5392,7 +6294,7 @@ async function workspaceBindCommand(workspaceKey, args) {
       tenantId: args.tenant ?? client3?.tenantId,
       endpoint: args.endpoint ?? client3?.endpoint
     });
-    await fs4.mkdir(rootDir, { recursive: true });
+    await fs6.mkdir(rootDir, { recursive: true });
     await writeWorkspaceContext(rootDir, context);
     writeWorkspaceBindResult(context, rootDir, args.output ?? "table");
     process.exit(0);
@@ -5427,7 +6329,7 @@ async function workspaceCreateCommand(workspaceKey, args) {
       tenantId: client3.tenantId,
       endpoint: client3.endpoint
     });
-    await fs4.mkdir(rootDir, { recursive: true });
+    await fs6.mkdir(rootDir, { recursive: true });
     await writeWorkspaceContext(rootDir, context);
     writeWorkspaceCreateResult(
       {
@@ -5464,23 +6366,23 @@ async function workspacePullCommand(args) {
       tenantId: client3.tenantId ?? existing?.tenantId,
       endpoint: client3.endpoint ?? existing?.endpoint
     });
-    await fs4.mkdir(rootDir, { recursive: true });
+    await fs6.mkdir(rootDir, { recursive: true });
     await writeWorkspaceContext(rootDir, context);
     const files = await listWorkspaceFiles(client3.raw(), workspaceKey, { pageSize: 5e3 });
     const miniApps = detectRemoteMiniApps(files.data);
     const pulledMiniApps = [];
     for (const appCode of miniApps) {
-      const result = await pullMiniAppProject({
+      const result2 = await pullMiniAppProject({
         http: client3.raw(),
         appCode,
         workspaceKey,
-        targetDir: path3.join(rootDir, MINI_APPS_DIR, appCode),
+        targetDir: path5.join(rootDir, MINI_APPS_DIR, appCode),
         tenantId: client3.tenantId,
         endpoint: client3.endpoint,
         profile: args.profile ?? client3.profile,
         force: !!args.force
       });
-      pulledMiniApps.push(result);
+      pulledMiniApps.push(result2);
     }
     const rawFiles = files.data.filter(
       (file) => !isDirectoryMarker(file.relativePath) && !isMiniAppPath(file.relativePath)
@@ -5489,7 +6391,7 @@ async function workspacePullCommand(args) {
     const rawRemoteByLocalPath = /* @__PURE__ */ new Map();
     for (const file of rawFiles) {
       const content = await loadWorkspaceFileContent(client3.raw(), file.id);
-      const target = path3.join(rootDir, content.relativePath);
+      const target = path5.join(rootDir, content.relativePath);
       await writeTextFile(target, content.content, !!args.force);
       pulledRawFiles.push(content.relativePath);
       rawRemoteByLocalPath.set(content.relativePath, file);
@@ -5536,10 +6438,10 @@ async function workspaceAddMiniCommand(appCode, args) {
       fields: args.fields,
       defaults: args.defaults
     });
-    const result = await initMiniAppProject({
+    const result2 = await initMiniAppProject({
       appCode,
       workspaceKey: context.workspaceKey,
-      targetDir: path3.join(rootDir, MINI_APPS_DIR, appCode),
+      targetDir: path5.join(rootDir, MINI_APPS_DIR, appCode),
       name: args.name,
       defaultSurface: parseSurface(args.surface),
       templateKind,
@@ -5553,7 +6455,7 @@ async function workspaceAddMiniCommand(appCode, args) {
       profile: args.env ?? args.profile ?? client3?.profile ?? context.profile,
       force: !!args.force
     });
-    writeWorkspaceAddMiniResult(result, rootDir, args.output ?? "table");
+    writeWorkspaceAddMiniResult(result2, rootDir, args.output ?? "table");
     process.exit(0);
   } catch (e) {
     exitWorkspaceError(e, args.env ?? args.profile);
@@ -5633,12 +6535,12 @@ async function workspacePushCommand(args) {
     });
     const results = [];
     for (const app of miniApps) {
-      const result = await pushMiniAppProject({
+      const result2 = await pushMiniAppProject({
         http: client3.raw(),
         rootDir: app.dir,
         dryRun: !!args.dryRun
       });
-      results.push({ app, result });
+      results.push({ app, result: result2 });
     }
     writeWorkspacePushResult(rawResult, results, args.output ?? "table");
     process.exit(
@@ -5780,7 +6682,7 @@ function removedMiniCommand() {
   );
 }
 function resolveRootDir(dir) {
-  return path3.resolve(dir ?? ".");
+  return path5.resolve(dir ?? ".");
 }
 function buildWorkspaceContext(args) {
   return {
@@ -5796,7 +6698,7 @@ function buildWorkspaceContext(args) {
 async function readWorkspaceContext(rootDir) {
   try {
     const parsed = JSON.parse(
-      await fs4.readFile(path3.join(rootDir, WORKSPACE_CONTEXT_FILE), "utf-8")
+      await fs6.readFile(path5.join(rootDir, WORKSPACE_CONTEXT_FILE), "utf-8")
     );
     if (parsed.kind !== WORKSPACE_CONTEXT_KIND || parsed.version !== WORKSPACE_CONTEXT_VERSION) {
       throw new Error(`${WORKSPACE_CONTEXT_FILE} is not an HCM workspace context`);
@@ -5825,25 +6727,25 @@ async function requireWorkspaceContext(rootDir) {
   return context;
 }
 async function writeWorkspaceContext(rootDir, context) {
-  await fs4.writeFile(
-    path3.join(rootDir, WORKSPACE_CONTEXT_FILE),
+  await fs6.writeFile(
+    path5.join(rootDir, WORKSPACE_CONTEXT_FILE),
     JSON.stringify(context, null, 2) + "\n"
   );
 }
 async function writeTextFile(file, content, force) {
   try {
-    await fs4.access(file);
+    await fs6.access(file);
     if (!force) throw new Error(`${file} already exists; use --force to overwrite`);
   } catch (e) {
     if (e.code !== "ENOENT") throw e;
   }
-  await fs4.mkdir(path3.dirname(file), { recursive: true });
-  await fs4.writeFile(file, content);
+  await fs6.mkdir(path5.dirname(file), { recursive: true });
+  await fs6.writeFile(file, content);
 }
 async function readWorkspaceRawManifest(rootDir, context) {
   try {
     const parsed = JSON.parse(
-      await fs4.readFile(path3.join(rootDir, WORKSPACE_STATE_DIR, WORKSPACE_PULL_MANIFEST_FILE), "utf-8")
+      await fs6.readFile(path5.join(rootDir, WORKSPACE_STATE_DIR, WORKSPACE_PULL_MANIFEST_FILE), "utf-8")
     );
     if (parsed.version !== WORKSPACE_CONTEXT_VERSION || parsed.workspaceKey !== context.workspaceKey) {
       throw new Error(`${WORKSPACE_PULL_MANIFEST_FILE} does not match workspace ${context.workspaceKey}`);
@@ -5861,8 +6763,8 @@ async function readWorkspaceRawManifest(rootDir, context) {
   }
 }
 async function writeWorkspaceRawState(rootDir, context, files, remoteByLocalPath) {
-  const stateDir = path3.join(rootDir, WORKSPACE_STATE_DIR);
-  await fs4.mkdir(stateDir, { recursive: true });
+  const stateDir = path5.join(rootDir, WORKSPACE_STATE_DIR);
+  await fs6.mkdir(stateDir, { recursive: true });
   const snapshots = files.map((file) => ({
     localPath: file.localPath,
     remotePath: file.localPath,
@@ -5871,8 +6773,8 @@ async function writeWorkspaceRawState(rootDir, context, files, remoteByLocalPath
     size: file.size,
     lastModified: remoteByLocalPath.get(file.localPath)?.lastModified
   }));
-  await fs4.writeFile(
-    path3.join(stateDir, WORKSPACE_PULL_MANIFEST_FILE),
+  await fs6.writeFile(
+    path5.join(stateDir, WORKSPACE_PULL_MANIFEST_FILE),
     JSON.stringify(
       {
         version: WORKSPACE_CONTEXT_VERSION,
@@ -5894,10 +6796,10 @@ async function readWorkspaceRawLocalFiles(rootDir) {
   return files;
 }
 async function walkWorkspaceRawFiles(rootDir, relativeDir, files) {
-  const absoluteDir = path3.join(rootDir, relativeDir);
+  const absoluteDir = path5.join(rootDir, relativeDir);
   let entries;
   try {
-    entries = await fs4.readdir(absoluteDir, { withFileTypes: true });
+    entries = await fs6.readdir(absoluteDir, { withFileTypes: true });
   } catch (e) {
     if (e.code === "ENOENT") return;
     throw e;
@@ -5905,19 +6807,19 @@ async function walkWorkspaceRawFiles(rootDir, relativeDir, files) {
   for (const entry of entries) {
     if (entry.isDirectory() && RAW_WORKSPACE_EXCLUDED_DIRS.has(entry.name)) continue;
     if (entry.isFile() && RAW_WORKSPACE_EXCLUDED_FILES.has(entry.name)) continue;
-    const localPath = normalizeRelativePath(path3.posix.join(toPosix(relativeDir), entry.name));
-    const absolutePath = path3.join(rootDir, localPath);
+    const localPath = normalizeRelativePath(path5.posix.join(toPosix(relativeDir), entry.name));
+    const absolutePath = path5.join(rootDir, localPath);
     if (entry.isDirectory()) {
       await walkWorkspaceRawFiles(rootDir, localPath, files);
       continue;
     }
     if (!entry.isFile()) continue;
-    const content = await fs4.readFile(absolutePath, "utf-8");
+    const content = await fs6.readFile(absolutePath, "utf-8");
     files.push({
       localPath,
       absolutePath,
       content,
-      sha256: sha2562(content),
+      sha256: sha2564(content),
       size: Buffer.byteLength(content, "utf-8")
     });
   }
@@ -5931,13 +6833,13 @@ async function pushWorkspaceRawFiles(args) {
   const localFiles = await readWorkspaceRawLocalFiles(args.rootDir);
   const remoteFiles = await loadWorkspaceRawRemoteFiles(args.http, args.context.workspaceKey);
   const plan = buildWorkspaceRawPushPlan(manifest2, localFiles, remoteFiles);
-  const result = {
+  const result2 = {
     workspaceKey: args.context.workspaceKey,
     dryRun: args.dryRun,
     operations: plan.operations,
     conflicts: plan.conflicts
   };
-  if (args.dryRun || plan.conflicts.length) return result;
+  if (args.dryRun || plan.conflicts.length) return result2;
   const localByPath = new Map(localFiles.map((file) => [file.localPath, file]));
   for (const operation of plan.operations) {
     if (operation.operation === "skip") continue;
@@ -5963,17 +6865,17 @@ async function pushWorkspaceRawFiles(args) {
   const latestRemoteFiles = await loadWorkspaceRawRemoteFiles(args.http, args.context.workspaceKey);
   const latestRemoteByLocalPath = new Map(latestRemoteFiles.map((file) => [file.item.relativePath, file.item]));
   await writeWorkspaceRawState(args.rootDir, args.context, localFiles, latestRemoteByLocalPath);
-  return result;
+  return result2;
 }
 async function loadWorkspaceRawRemoteFiles(http, workspaceKey) {
   const list = await listWorkspaceFiles(http, workspaceKey, { pageSize: 5e3 });
-  const result = [];
+  const result2 = [];
   for (const item of list.data) {
     if (isDirectoryMarker(item.relativePath) || isMiniAppPath(item.relativePath)) continue;
     const content = await loadWorkspaceFileContent(http, item.id);
-    result.push({ item, content: content.content });
+    result2.push({ item, content: content.content });
   }
-  return result;
+  return result2;
 }
 function buildWorkspaceRawPushPlan(manifest2, localFiles, remoteFiles) {
   const status = computeWorkspaceRawStatus(manifest2, localFiles);
@@ -5984,7 +6886,7 @@ function buildWorkspaceRawPushPlan(manifest2, localFiles, remoteFiles) {
   for (const entry of status) {
     const remote = remoteByLocal.get(entry.localPath);
     const base = baseByLocal.get(entry.localPath);
-    const remoteSha = remote ? sha2562(remote.content) : void 0;
+    const remoteSha = remote ? sha2564(remote.content) : void 0;
     if (entry.status === "added") {
       if (remote) {
         conflicts.push(workspaceRawConflict(entry, "remote file already exists but was not in local snapshot"));
@@ -6086,15 +6988,15 @@ function workspaceRawConflict(entry, reason) {
   };
 }
 async function discoverMiniApps(rootDir) {
-  const appsRoot = path3.join(rootDir, MINI_APPS_DIR);
+  const appsRoot = path5.join(rootDir, MINI_APPS_DIR);
   let entries;
   try {
-    entries = await fs4.readdir(appsRoot, { withFileTypes: true });
+    entries = await fs6.readdir(appsRoot, { withFileTypes: true });
   } catch (e) {
     if (e.code === "ENOENT") return [];
     throw e;
   }
-  return entries.filter((entry) => entry.isDirectory()).map((entry) => ({ appCode: entry.name, dir: path3.join(appsRoot, entry.name) })).sort((a, b) => a.appCode.localeCompare(b.appCode));
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => ({ appCode: entry.name, dir: path5.join(appsRoot, entry.name) })).sort((a, b) => a.appCode.localeCompare(b.appCode));
 }
 function detectRemoteMiniApps(files) {
   const appCodes = /* @__PURE__ */ new Set();
@@ -6183,17 +7085,17 @@ function parseModelKey(value) {
   }
   return model;
 }
-function parseJsonObject(value, flagName) {
+function parseJsonObject(value, flagName2) {
   if (!value) return void 0;
   if (isAuto(value)) return void 0;
   let parsed;
   try {
     parsed = JSON.parse(value);
   } catch {
-    throw new Error(`${flagName} must be valid JSON object`);
+    throw new Error(`${flagName2} must be valid JSON object`);
   }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`${flagName} must be valid JSON object`);
+    throw new Error(`${flagName2} must be valid JSON object`);
   }
   return parsed;
 }
@@ -6247,9 +7149,9 @@ function normalizeRelativePath(value) {
   return normalized;
 }
 function toPosix(value) {
-  return value.split(path3.sep).join("/");
+  return value.split(path5.sep).join("/");
 }
-function sha2562(content) {
+function sha2564(content) {
   return crypto.createHash("sha256").update(content, "utf-8").digest("hex");
 }
 function stringRequired(value, field) {
@@ -6316,52 +7218,52 @@ function writeWorkspaceBindResult(context, rootDir, format) {
     ].join("\n") + "\n"
   );
 }
-function writeWorkspaceCreateResult(result, format) {
+function writeWorkspaceCreateResult(result2, format) {
   if (format !== "table") {
-    process.stdout.write(formatObject16(result, { format }) + "\n");
+    process.stdout.write(formatObject16(result2, { format }) + "\n");
     return;
   }
   process.stdout.write(
     [
-      `workspace created: ${result.workspaceKey}`,
-      `id: ${result.id}`,
-      `directory: ${result.rootDir}`,
-      `profile: ${result.profile}`,
-      `tenant: ${result.tenantId}`,
-      `activated: ${result.activated ? "yes" : "no"}`
+      `workspace created: ${result2.workspaceKey}`,
+      `id: ${result2.id}`,
+      `directory: ${result2.rootDir}`,
+      `profile: ${result2.profile}`,
+      `tenant: ${result2.tenantId}`,
+      `activated: ${result2.activated ? "yes" : "no"}`
     ].join("\n") + "\n"
   );
 }
-function writeWorkspacePullResult(result, format) {
+function writeWorkspacePullResult(result2, format) {
   if (format !== "table") {
-    process.stdout.write(formatObject16(result, { format }) + "\n");
+    process.stdout.write(formatObject16(result2, { format }) + "\n");
     return;
   }
   const lines = [
-    `workspace pulled: ${result.workspaceKey}`,
-    `directory: ${result.rootDir}`,
-    `remote files: ${result.totalRemoteFiles}`,
-    `mini apps: ${result.miniApps.length}`,
-    `raw files: ${result.rawFiles.length}`
+    `workspace pulled: ${result2.workspaceKey}`,
+    `directory: ${result2.rootDir}`,
+    `remote files: ${result2.totalRemoteFiles}`,
+    `mini apps: ${result2.miniApps.length}`,
+    `raw files: ${result2.rawFiles.length}`
   ];
-  if (result.miniApps.length) {
+  if (result2.miniApps.length) {
     lines.push("mini artifacts:");
-    for (const app of result.miniApps) lines.push(`  - ${app.appCode}: ${app.files} files`);
+    for (const app of result2.miniApps) lines.push(`  - ${app.appCode}: ${app.files} files`);
   }
   process.stdout.write(lines.join("\n") + "\n");
 }
-function writeWorkspaceAddMiniResult(result, rootDir, format) {
+function writeWorkspaceAddMiniResult(result2, rootDir, format) {
   if (format !== "table") {
-    process.stdout.write(formatObject16({ ...result, workspaceRoot: rootDir }, { format }) + "\n");
+    process.stdout.write(formatObject16({ ...result2, workspaceRoot: rootDir }, { format }) + "\n");
     return;
   }
   process.stdout.write(
     [
-      `workspace artifact added: mini:${result.appCode}`,
-      `workspace: ${result.workspaceKey}`,
+      `workspace artifact added: mini:${result2.appCode}`,
+      `workspace: ${result2.workspaceKey}`,
       `workspace root: ${rootDir}`,
-      `directory: ${result.targetDir}`,
-      `files: ${result.files.length}`
+      `directory: ${result2.targetDir}`,
+      `files: ${result2.files.length}`
     ].join("\n") + "\n"
   );
 }
@@ -6546,8 +7448,8 @@ import {
   deleteIdentity as deleteIdentity2,
   loadGlobalConfig as loadGlobalConfig8,
   TokenStore as TokenStore3,
-  CliError as CliError17,
-  CliErrorCode as CliErrorCode16
+  CliError as CliError19,
+  CliErrorCode as CliErrorCode18
 } from "@hcmai/sdk";
 async function identityList(args) {
   try {
@@ -6575,8 +7477,8 @@ async function identityUse(name) {
   try {
     const meta2 = await loadIdentity4(name);
     const env2 = await loadEnv7(meta2.env).catch(() => {
-      throw new CliError17({
-        code: CliErrorCode16.IDENTITY_NOT_IN_ENV,
+      throw new CliError19({
+        code: CliErrorCode18.IDENTITY_NOT_IN_ENV,
         message: `identity '${name}' references env '${meta2.env}' which no longer exists. Re-create the env, or remove this orphan: hcm identity remove ${name}`
       });
     });
@@ -6610,6 +7512,768 @@ async function identityRemove(name) {
   }
 }
 
+// src/commands/delivery.ts
+import { createHash as createHash5 } from "crypto";
+import { formatObject as formatObject17 } from "@hcmai/sdk";
+var APPROVAL_BYPASS_FLAGS = /* @__PURE__ */ new Set(["-y", "--yes", "--force", "--auto-approve"]);
+var CREDENTIAL_FLAGS = /* @__PURE__ */ new Set([
+  "--password",
+  "--password-stdin",
+  "--client-secret",
+  "--pat",
+  "--pat-stdin",
+  "--new-password",
+  "--new-password-stdin"
+]);
+var PAYLOAD_FLAGS = ["--data", "--params"];
+var GUARDED_EXECUTOR_REASON_CODES = /* @__PURE__ */ new Set([
+  "record-create",
+  "record-update",
+  "cache-mutation",
+  "setting-write"
+]);
+function assessDeliveryCommand(inputArgv) {
+  const argv = inputArgv[0] === "--" ? inputArgv.slice(1) : [...inputArgv];
+  const commandSha256 = sha2565(JSON.stringify(argv));
+  const name = argv[0] ?? "";
+  const subcommand = argv[1] && !argv[1].startsWith("-") ? argv[1] : void 0;
+  const envAlias = flagValue(argv, "--env");
+  const identityAlias = flagValue(argv, "--as");
+  const sensitiveFlags = [...new Set(PAYLOAD_FLAGS.filter((flag) => hasFlag(argv, flag)))];
+  const target = summarizeTarget(argv);
+  let classification = classify(argv);
+  const invalidPayload = payloadError(argv);
+  if (invalidPayload) {
+    classification = forbidden("invalid-input", "JSON payload \u65E0\u6548\uFF0C\u4E0D\u80FD\u8FDB\u5165\u4EFB\u4F55\u6267\u884C\u8DEF\u5F84\u3002");
+  }
+  const requirements = [];
+  const guardedExecutionAvailable = classification.risk === "R2" && GUARDED_EXECUTOR_REASON_CODES.has(classification.reasonCode);
+  if (classification.risk === "R2") {
+    if (!envAlias) requirements.push("explicit-env");
+    if (!identityAlias) requirements.push("explicit-identity");
+    if (guardedExecutionAvailable) {
+      requirements.push("change-plan", "rollback-plan", "human-approval", "single-use-plan");
+    } else {
+      requirements.push("guarded-executor");
+    }
+  } else if (classification.risk === "R3") {
+    requirements.push("governance-escalation");
+  }
+  const allowed = classification.risk === "R0" || classification.risk === "R1";
+  return {
+    schemaVersion: 1,
+    contractVersion: "2026-08-28",
+    assessmentId: sha2565(`2026-08-28
+${commandSha256}`).slice(0, 24),
+    commandSha256,
+    command: { name: name || "(empty)", ...subcommand ? { subcommand } : {} },
+    ...classification,
+    guardedExecutionAvailable,
+    environment: {
+      ...envAlias ? { envAlias } : {},
+      ...identityAlias ? { identityAlias } : {}
+    },
+    target,
+    requirements,
+    evidenceRequirements: evidenceFor(classification.risk),
+    sensitiveFlags,
+    modePolicy: {
+      planOnly: allowed ? "allow" : "deny",
+      controlled: allowed || guardedExecutionAvailable ? "allow" : "deny"
+    }
+  };
+}
+function deliveryAssessCommand(argv, args) {
+  const assessment = assessDeliveryCommand(argv);
+  process.stdout.write(formatObject17(assessment, { format: args.output ?? "json" }) + "\n");
+}
+function classify(argv) {
+  const name = argv[0] ?? "";
+  const subcommand = argv[1] ?? "";
+  if (argv.some((arg) => APPROVAL_BYPASS_FLAGS.has(flagName(arg)))) {
+    return forbidden("approval-bypass", "\u547D\u4EE4\u5305\u542B\u8DF3\u8FC7\u786E\u8BA4\u7684\u65D7\u6807\uFF0C\u987E\u95EE\u4EA4\u4ED8\u9762\u4E0D\u6267\u884C\u3002");
+  }
+  if (argv.some((arg) => CREDENTIAL_FLAGS.has(flagName(arg)))) {
+    return forbidden("credential-governance", "\u547D\u4EE4\u643A\u5E26\u8EAB\u4EFD\u51ED\u636E\u53C2\u6570\uFF0C\u5FC5\u987B\u8F6C\u4EA4\u8EAB\u4EFD\u6CBB\u7406\u6D41\u7A0B\u3002");
+  }
+  if (name === "version") return direct("R0", "product-discovery", "product-discovery");
+  if (name === "delivery" && subcommand === "assess") {
+    return direct("R0", "local-discovery", "risk-assessment");
+  }
+  if (name === "skills") {
+    if (subcommand === "list" || subcommand === "show") {
+      return direct("R0", "product-discovery", "skill-discovery");
+    }
+    if (subcommand === "sync" || subcommand === "install") {
+      return direct("R1", "managed-local-write", "skill-managed-write");
+    }
+    return forbidden("unknown-command", "\u672A\u77E5 skills \u5B50\u547D\u4EE4\u6309\u6700\u9AD8\u98CE\u9669\u5173\u95ED\u3002");
+  }
+  if (name === "env") {
+    if (subcommand === "list" || subcommand === "current" || subcommand === "show") {
+      return direct("R0", "local-discovery", "environment-read");
+    }
+    return forbidden("identity-governance", "\u73AF\u5883\u65B0\u589E\u3001\u5207\u6362\u3001\u7F16\u8F91\u6216\u5220\u9664\u5C5E\u4E8E\u6CBB\u7406\u64CD\u4F5C\u3002");
+  }
+  if (name === "identity") {
+    if (subcommand === "list") return direct("R0", "local-discovery", "identity-read");
+    return forbidden("identity-governance", "\u8EAB\u4EFD\u5207\u6362\u6216\u5220\u9664\u5C5E\u4E8E\u6CBB\u7406\u64CD\u4F5C\u3002");
+  }
+  if (name === "query" || name === "describe" || name === "trace") {
+    return direct("R1", "remote-read", "business-read");
+  }
+  if (name === "cache") {
+    if (subcommand === "stats") return direct("R1", "remote-read", "cache-read");
+    if (subcommand === "clear" || subcommand === "clear-meta") {
+      return guarded("operational-write", "cache-mutation");
+    }
+  }
+  if (name === "meta") {
+    if (subcommand === "list" || subcommand === "get") {
+      return direct("R1", "remote-read", "metadata-read");
+    }
+    if (subcommand === "set" && hasFlag(argv, "--dry-run")) {
+      return direct("R1", "local-validation", "metadata-dry-run");
+    }
+    if (subcommand === "set") return guarded("tenant-config-write", "metadata-write");
+    if (subcommand === "delete") return forbidden("destructive", "\u5143\u6570\u636E\u5220\u9664\u4E0D\u53EF\u7531\u987E\u95EE\u63D2\u4EF6\u6267\u884C\u3002");
+  }
+  if (name === "setting") {
+    if (subcommand === "get") return direct("R1", "remote-read", "setting-read");
+    if (subcommand === "set" && hasFlag(argv, "--dry-run")) {
+      return direct("R1", "local-validation", "setting-dry-run");
+    }
+    if (subcommand === "set" || subcommand === "reset") {
+      return guarded("tenant-config-write", "setting-write");
+    }
+  }
+  if (name === "workspace") {
+    if (subcommand === "push" && hasFlag(argv, "--dry-run")) {
+      return direct("R1", "remote-read", "workspace-push-dry-run");
+    }
+    if (["list", "active", "status", "validate", "verify", "preview"].includes(subcommand)) {
+      return direct("R1", "remote-read", "workspace-read");
+    }
+    if (subcommand === "pull") {
+      return direct("R1", "managed-local-write", "workspace-pull");
+    }
+    if (subcommand === "bind" || subcommand === "add" && argv[2] === "mini") {
+      return guarded("managed-local-write", "workspace-local-change");
+    }
+    if (subcommand === "create") return guarded("tenant-write", "workspace-create");
+    if (subcommand === "push") return forbidden("publish", "\u5F00\u53D1\u7A7A\u95F4\u53D1\u5E03\u5C5E\u4E8E R3\u3002");
+  }
+  if (name === "import") {
+    if (hasFlag(argv, "--dry-run")) {
+      return direct("R1", "local-validation", "import-dry-run");
+    }
+    return guarded("bulk-tenant-write", "import-write");
+  }
+  if (name === "create" || name === "update") {
+    return guarded("tenant-write", name === "create" ? "record-create" : "record-update");
+  }
+  if (name === "upload") return guarded("tenant-write", "document-upload");
+  if (name === "download") return direct("R1", "managed-local-write", "document-download");
+  if (name === "action") {
+    return forbidden(
+      "action-effect-unclassified",
+      "Action \u5C1A\u65E0\u7EDF\u4E00 destructive/publish \u8BED\u4E49\uFF0C\u9996\u7248\u4E0D\u80FD\u6309\u540D\u79F0\u731C\u6D4B\u540E\u653E\u884C\u3002"
+    );
+  }
+  if (name === "delete" || name === "meta" && subcommand === "delete") {
+    return forbidden("destructive", "\u5220\u9664\u64CD\u4F5C\u4E0D\u8FDB\u5165\u987E\u95EE\u63D2\u4EF6\u6267\u884C\u9762\u3002");
+  }
+  if (name === "tenant") {
+    return forbidden("tenant-governance", "\u79DF\u6237\u5F00\u901A\u6216\u6CBB\u7406\u5FC5\u987B\u5347\u7EA7\u6CBB\u7406\u4EBA\u5458\u3002");
+  }
+  if (name === "login" || name === "logout") {
+    return forbidden("identity-governance", "\u767B\u5F55\u4E0E\u767B\u51FA\u5C5E\u4E8E\u8EAB\u4EFD\u6CBB\u7406\u64CD\u4F5C\u3002");
+  }
+  if (name === "chat") {
+    return forbidden("agent-autonomy", "\u987E\u95EE\u63D2\u4EF6\u4E0D\u901A\u8FC7\u5D4C\u5957\u6570\u5B57\u5458\u5DE5\u5BF9\u8BDD\u6269\u5927\u81EA\u6CBB\u6267\u884C\u9762\u3002");
+  }
+  return forbidden("unknown-command", "\u672A\u77E5\u547D\u4EE4\u6309\u6700\u9AD8\u98CE\u9669\u5173\u95ED\u3002");
+}
+function summarizeTarget(argv) {
+  const name = argv[0] ?? "";
+  const subcommand = argv[1] ?? "";
+  const target = {};
+  if (["query", "describe", "create", "update", "delete"].includes(name) && subcommand) {
+    target.model = subcommand;
+  }
+  if (name === "action" && subcommand) target.action = subcommand;
+  if (name === "skills" && argv[2] && !argv[2].startsWith("-")) target.skill = argv[2];
+  if (name === "meta" && argv[2] && !argv[2].startsWith("-")) target.path = argv[2];
+  if (name === "cache" && argv[2] && !argv[2].startsWith("-")) {
+    target.cacheOperation = subcommand;
+    target.model = argv[2];
+  }
+  if (name === "setting" && argv[2] && !argv[2].startsWith("-")) {
+    target.domain = argv[2];
+    const settingKeys = valuesAfterFlag(argv, "--set").map((assignment) => assignment.split("=", 1)[0]).filter((key) => Boolean(key)).sort();
+    if (settingKeys.length > 0) target.settingKeys = settingKeys;
+  }
+  const id = flagValue(argv, "--id");
+  if (id) target.recordIdSha256 = sha2565(id);
+  for (const flag of PAYLOAD_FLAGS) {
+    const raw = flagValue(argv, flag);
+    if (!raw) continue;
+    target.payloadSha256 = sha2565(raw);
+    try {
+      const parsed = JSON.parse(raw);
+      if (isPlainObject(parsed)) target.fieldNames = Object.keys(parsed).sort();
+    } catch {
+    }
+  }
+  return target;
+}
+function payloadError(argv) {
+  for (const flag of PAYLOAD_FLAGS) {
+    const raw = flagValue(argv, flag);
+    if (raw === void 0) continue;
+    try {
+      const parsed = JSON.parse(raw);
+      if (!isPlainObject(parsed)) return true;
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+function direct(risk, effect, reasonCode) {
+  return {
+    risk,
+    execution: "direct",
+    effect,
+    reasonCode,
+    reason: risk === "R0" ? "\u7EAF\u53D1\u73B0\u64CD\u4F5C\uFF0C\u53EF\u76F4\u63A5\u6267\u884C\u3002" : "\u53EA\u8BFB\u6216\u53D7\u7BA1\u672C\u5730\u64CD\u4F5C\uFF0C\u53EF\u76F4\u63A5\u6267\u884C\u5E76\u4FDD\u7559\u7ED3\u679C\u3002"
+  };
+}
+function guarded(effect, reasonCode) {
+  return {
+    risk: "R2",
+    execution: "guarded",
+    effect,
+    reasonCode,
+    reason: "\u666E\u901A\u526F\u4F5C\u7528\u64CD\u4F5C\uFF1B\u53EA\u5141\u8BB8\u5728 controlled \u9879\u76EE\u4E2D\u901A\u8FC7 delivery prepare + delivery execute \u5355\u6B21\u53D7\u63A7\u6267\u884C\u3002"
+  };
+}
+function forbidden(reasonCode, reason) {
+  return { risk: "R3", execution: "forbidden", effect: reasonCode, reasonCode, reason };
+}
+function evidenceFor(risk) {
+  if (risk === "R0") return ["command-digest", "discovery-result"];
+  if (risk === "R1") return ["command-digest", "target-aliases", "result-summary"];
+  if (risk === "R2") {
+    return [
+      "command-digest",
+      "explicit-target-aliases",
+      "pre-state-or-dry-run",
+      "rollback-plan",
+      "execution-receipt",
+      "post-verification"
+    ];
+  }
+  return ["governance-decision"];
+}
+function flagValue(argv, flag) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === void 0) continue;
+    if (arg === flag) return argv[index + 1];
+    if (arg.startsWith(`${flag}=`)) return arg.slice(flag.length + 1);
+  }
+  return void 0;
+}
+function hasFlag(argv, flag) {
+  return argv.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
+function flagName(arg) {
+  const equals = arg.indexOf("=");
+  return equals < 0 ? arg : arg.slice(0, equals);
+}
+function valuesAfterFlag(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index < 0) return [];
+  const values = [];
+  for (let cursor = index + 1; cursor < argv.length; cursor += 1) {
+    const value = argv[cursor];
+    if (value === void 0 || value.startsWith("-")) break;
+    values.push(value);
+  }
+  return values;
+}
+function sha2565(value) {
+  return createHash5("sha256").update(value).digest("hex");
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/commands/delivery-execution.ts
+import { createHash as createHash6, randomBytes as secureRandomBytes } from "crypto";
+import { spawn } from "child_process";
+import { createReadStream as createReadStream2, promises as fs7 } from "fs";
+import path6 from "path";
+import { CliError as CliError20, CliErrorCode as CliErrorCode19, formatObject as formatObject18 } from "@hcmai/sdk";
+init_exit();
+var EXECUTION_CONTRACT_VERSION = "2026-08-28.controlled-v1";
+var DEFAULT_TTL_SECONDS = 15 * 60;
+var MIN_TTL_SECONDS = 60;
+var MAX_TTL_SECONDS = 60 * 60;
+var PLAN_ID_PATTERN = /^[a-f0-9]{24}$/;
+async function prepareDeliveryExecution(input) {
+  const project = await realProject(input.project);
+  await readProjectMode(project);
+  const assessment = assessDeliveryCommand(input.argv);
+  assertGuardedAssessment(assessment, input.argv);
+  const ttlSeconds = input.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  if (!Number.isInteger(ttlSeconds) || ttlSeconds < MIN_TTL_SECONDS || ttlSeconds > MAX_TTL_SECONDS) {
+    throw invalid4(`--ttl-seconds \u5FC5\u987B\u662F ${MIN_TTL_SECONDS} \u5230 ${MAX_TTL_SECONDS} \u7684\u6574\u6570`);
+  }
+  const change = await bindDocument(project, input.changeRef, "\u53D8\u66F4\u8BF4\u660E");
+  const rollback = await bindDocument(project, input.rollbackRef, "\u56DE\u6EDA\u8BF4\u660E");
+  const evidence = await bindEvidenceDirectory(project, input.evidenceDir);
+  const { bytes: lockBytes, runtime: lockedRuntime } = await readChironLock(project);
+  const runtime = await (input.runtimeIdentity ?? currentRuntimeIdentity)();
+  assertRuntimeMatches(runtime, lockedRuntime);
+  const created = (input.now ?? (() => /* @__PURE__ */ new Date()))();
+  if (Number.isNaN(created.getTime())) throw invalid4("\u5F53\u524D\u65F6\u95F4\u65E0\u6548");
+  const core = {
+    schemaVersion: 1,
+    contractVersion: EXECUTION_CONTRACT_VERSION,
+    nonceSha256: sha2566((input.randomBytes ?? secureRandomBytes)(12)),
+    createdAt: created.toISOString(),
+    expiresAt: new Date(created.getTime() + ttlSeconds * 1e3).toISOString(),
+    chironLockSha256: sha2566(lockBytes),
+    runtime,
+    assessment,
+    documents: { change, rollback },
+    evidenceDir: evidence.relative
+  };
+  const planId = sha2566(canonicalJson(core)).slice(0, 24);
+  const plan = { ...core, planId };
+  const plansDir = path6.join(project, ".hcm-delivery", "execution-plans");
+  await safeManagedDirectory(project, ".hcm-delivery/execution-plans", plansDir);
+  const planFile = path6.join(plansDir, `${planId}.json`);
+  try {
+    await fs7.writeFile(planFile, `${JSON.stringify(plan, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+  } catch (cause) {
+    throw invalid4(`\u6267\u884C\u8BA1\u5212\u5199\u5165\u5931\u8D25\u6216 planId \u5DF2\u5B58\u5728\uFF1A${planId}`, cause);
+  }
+  return plan;
+}
+async function executeDeliveryPlan(input) {
+  if (!PLAN_ID_PATTERN.test(input.planId)) throw invalid4("planId \u5FC5\u987B\u662F 24 \u4F4D\u5C0F\u5199\u5341\u516D\u8FDB\u5236");
+  const project = await realProject(input.project);
+  if (await readProjectMode(project) !== "controlled") {
+    throw invalid4("\u9879\u76EE\u4E0D\u662F controlled\uFF0C\u4E0D\u80FD\u6267\u884C R2 \u8BA1\u5212");
+  }
+  const planFile = path6.join(project, ".hcm-delivery", "execution-plans", `${input.planId}.json`);
+  const plan = await readPlan(project, planFile);
+  if (plan.planId !== input.planId || computePlanId(plan) !== input.planId) {
+    throw invalid4("\u6267\u884C\u8BA1\u5212\u5185\u5BB9\u4E0E planId \u6458\u8981\u4E0D\u4E00\u81F4");
+  }
+  const now = (input.now ?? (() => /* @__PURE__ */ new Date()))();
+  if (Number.isNaN(now.getTime())) throw invalid4("\u5F53\u524D\u65F6\u95F4\u65E0\u6548");
+  const expiresAt = Date.parse(plan.expiresAt);
+  const createdAt = Date.parse(plan.createdAt);
+  if (!Number.isFinite(createdAt) || !Number.isFinite(expiresAt) || expiresAt - createdAt < MIN_TTL_SECONDS * 1e3 || expiresAt - createdAt > MAX_TTL_SECONDS * 1e3) {
+    throw invalid4("\u6267\u884C\u8BA1\u5212\u65F6\u95F4\u7A97\u53E3\u65E0\u6548");
+  }
+  if (now.getTime() < createdAt - 5e3) throw invalid4("\u5F53\u524D\u65F6\u95F4\u65E9\u4E8E\u8BA1\u5212\u521B\u5EFA\u65F6\u95F4");
+  if (now.getTime() > expiresAt) throw invalid4("\u6267\u884C\u8BA1\u5212\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0 prepare");
+  const assessment = assessDeliveryCommand(input.argv);
+  assertGuardedAssessment(assessment, input.argv);
+  if (canonicalJson(assessment) !== canonicalJson(plan.assessment)) {
+    throw invalid4("\u5B9E\u9645 argv \u4E0E\u6267\u884C\u8BA1\u5212\u7684\u547D\u4EE4\u6458\u8981\u6216\u98CE\u9669\u4E8B\u5B9E\u4E0D\u4E00\u81F4");
+  }
+  const { bytes: lockBytes, runtime: lockedRuntime } = await readChironLock(project);
+  if (sha2566(lockBytes) !== plan.chironLockSha256) {
+    throw invalid4("Chiron \u9501\u6458\u8981\u5DF2\u6F02\u79FB\uFF0C\u8BF7\u91CD\u65B0\u8BC4\u4F30\u5E76 prepare");
+  }
+  const runtime = await (input.runtimeIdentity ?? currentRuntimeIdentity)();
+  assertRuntimeMatches(runtime, lockedRuntime);
+  if (canonicalJson(runtime) !== canonicalJson(plan.runtime)) {
+    throw invalid4("CLI \u8FD0\u884C\u65F6\u6458\u8981\u4E0E\u6267\u884C\u8BA1\u5212\u4E0D\u4E00\u81F4");
+  }
+  await assertDocumentUnchanged(project, plan.documents.change, "\u53D8\u66F4\u8BF4\u660E");
+  await assertDocumentUnchanged(project, plan.documents.rollback, "\u56DE\u6EDA\u8BF4\u660E");
+  const evidenceDir = await bindEvidenceDirectory(project, plan.evidenceDir);
+  const receiptFile = path6.join(evidenceDir.absolute, `${plan.planId}.receipt.json`);
+  if (await pathExists(receiptFile)) throw invalid4(`\u6267\u884C\u6536\u636E\u5DF2\u5B58\u5728\uFF0C\u62D2\u7EDD\u518D\u6B21\u6267\u884C\uFF1A${plan.planId}`);
+  const claimsDir = path6.join(project, ".hcm-delivery", "execution-claims");
+  await safeManagedDirectory(project, ".hcm-delivery/execution-claims", claimsDir);
+  const claimFile = path6.join(claimsDir, `${plan.planId}.json`);
+  try {
+    await fs7.writeFile(
+      claimFile,
+      `${JSON.stringify({ schemaVersion: 1, planId: plan.planId, claimedAt: now.toISOString() }, null, 2)}
+`,
+      { encoding: "utf8", mode: 384, flag: "wx" }
+    );
+  } catch (cause) {
+    throw invalid4(`\u6267\u884C\u8BA1\u5212\u5DF2\u6D88\u8D39\uFF0C\u62D2\u7EDD\u91CD\u590D\u6267\u884C\uFF1A${plan.planId}`, cause);
+  }
+  const stdoutHash = createHash6("sha256");
+  const stderrHash = createHash6("sha256");
+  const run = input.runCommand ?? runCurrentCliCommand;
+  let exitCode;
+  try {
+    ({ exitCode } = await run(input.argv, project, {
+      stdout: (chunk) => stdoutHash.update(chunk),
+      stderr: (chunk) => stderrHash.update(chunk)
+    }));
+  } catch (cause) {
+    stderrHash.update(
+      Buffer.from(`delivery executor failed: ${String(cause.message)}
+`)
+    );
+    exitCode = 1;
+  }
+  const completed = (input.now ?? (() => /* @__PURE__ */ new Date()))();
+  if (Number.isNaN(completed.getTime())) throw invalid4("\u5B8C\u6210\u65F6\u95F4\u65E0\u6548");
+  if (!Number.isInteger(exitCode) || exitCode < 0) exitCode = 1;
+  const receipt = {
+    schemaVersion: 1,
+    contractVersion: EXECUTION_CONTRACT_VERSION,
+    planId: plan.planId,
+    assessmentId: plan.assessment.assessmentId,
+    commandSha256: plan.assessment.commandSha256,
+    startedAt: now.toISOString(),
+    completedAt: completed.toISOString(),
+    exitCode,
+    stdoutSha256: stdoutHash.digest("hex"),
+    stderrSha256: stderrHash.digest("hex")
+  };
+  await writeReceiptExclusive(receiptFile, receipt);
+  return receipt;
+}
+async function deliveryPrepareCommand(argv, args) {
+  try {
+    if (!args.changeRef) throw invalid4("--change-ref <file> \u5FC5\u586B");
+    if (!args.rollbackRef) throw invalid4("--rollback-ref <file> \u5FC5\u586B");
+    if (!args.evidenceDir) throw invalid4("--evidence-dir <dir> \u5FC5\u586B");
+    const ttlSeconds = parseTtl(args.ttlSeconds);
+    const plan = await prepareDeliveryExecution({
+      project: args.project ?? process.cwd(),
+      argv,
+      changeRef: args.changeRef,
+      rollbackRef: args.rollbackRef,
+      evidenceDir: args.evidenceDir,
+      ...ttlSeconds === void 0 ? {} : { ttlSeconds }
+    });
+    process.stdout.write(formatObject18(plan, { format: args.output ?? "json" }) + "\n");
+  } catch (cause) {
+    exitWithError(cause);
+  }
+}
+async function deliveryExecuteCommand(planId, argv, args) {
+  try {
+    const receipt = await executeDeliveryPlan({
+      project: args.project ?? process.cwd(),
+      planId,
+      argv
+    });
+    process.stdout.write(formatObject18(receipt, { format: args.output ?? "json" }) + "\n");
+    process.exitCode = receipt.exitCode;
+  } catch (cause) {
+    exitWithError(cause);
+  }
+}
+async function readProjectMode(project) {
+  const file = path6.join(project, ".hcm-delivery", "project.yml");
+  const content = await readSafeFile(project, file, "\u9879\u76EE\u914D\u7F6E");
+  const match = content.toString("utf8").match(
+    /^deliveryMode:\s*(?:"(plan-only|controlled)"|'(plan-only|controlled)'|(plan-only|controlled))\s*$/m
+  );
+  const mode = match?.[1] ?? match?.[2] ?? match?.[3];
+  if (mode !== "plan-only" && mode !== "controlled") {
+    throw invalid4("project.yml \u7F3A\u5C11\u5408\u6CD5 deliveryMode");
+  }
+  return mode;
+}
+async function readChironLock(project) {
+  const file = path6.join(project, ".hcm-delivery", "chiron.lock.json");
+  const bytes = await readSafeFile(project, file, "Chiron \u9501");
+  let parsed;
+  try {
+    parsed = JSON.parse(bytes.toString("utf8"));
+  } catch (cause) {
+    throw invalid4("Chiron \u9501\u4E0D\u662F\u5408\u6CD5 JSON", cause);
+  }
+  const launch = parsed?.runtime?.launch;
+  if (!isRuntimeIdentity(launch)) throw invalid4("Chiron \u9501\u7F3A\u5C11\u5408\u6CD5 runtime.launch \u6458\u8981");
+  return { bytes, runtime: launch };
+}
+async function bindDocument(project, reference, label) {
+  const relative2 = safeRelative(reference, label);
+  if (!(relative2.startsWith("work/") || relative2.startsWith("decisions/"))) {
+    throw invalid4(`${label}\u5FC5\u987B\u4F4D\u4E8E\u9879\u76EE work/ \u6216 decisions/ \u4E0B`);
+  }
+  const file = path6.join(project, relative2);
+  const bytes = await readSafeFile(project, file, label);
+  return { path: relative2, sha256: sha2566(bytes) };
+}
+async function assertDocumentUnchanged(project, document, label) {
+  const current = await bindDocument(project, document.path, label);
+  if (current.sha256 !== document.sha256) throw invalid4(`${label}\u6458\u8981\u5DF2\u6F02\u79FB\uFF0C\u8BF7\u91CD\u65B0 prepare`);
+}
+async function bindEvidenceDirectory(project, reference) {
+  const relative2 = safeRelative(reference, "evidence \u76EE\u5F55");
+  if (!(relative2 === "evidence" || relative2.startsWith("evidence/"))) {
+    throw invalid4("evidence \u76EE\u5F55\u5FC5\u987B\u4F4D\u4E8E\u9879\u76EE evidence/ \u4E0B");
+  }
+  const absolute = path6.join(project, relative2);
+  await assertNoSymlinkComponents(project, relative2);
+  const stat = await fs7.stat(absolute).catch((cause) => {
+    throw invalid4(`evidence \u76EE\u5F55\u4E0D\u53EF\u7528\uFF1A${relative2}`, cause);
+  });
+  if (!stat.isDirectory()) throw invalid4(`evidence \u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55\uFF1A${relative2}`);
+  return { relative: relative2, absolute };
+}
+async function readPlan(project, file) {
+  const bytes = await readSafeFile(project, file, "\u6267\u884C\u8BA1\u5212");
+  let plan;
+  try {
+    plan = JSON.parse(bytes.toString("utf8"));
+  } catch (cause) {
+    throw invalid4("\u6267\u884C\u8BA1\u5212\u4E0D\u662F\u5408\u6CD5 JSON", cause);
+  }
+  if (!isExecutionPlan(plan)) throw invalid4("\u6267\u884C\u8BA1\u5212 schema \u65E0\u6548");
+  return plan;
+}
+function computePlanId(plan) {
+  const core = { ...plan };
+  delete core.planId;
+  return sha2566(canonicalJson(core)).slice(0, 24);
+}
+function assertGuardedAssessment(assessment, argv) {
+  if (assessment.risk !== "R2") throw invalid4("\u53EA\u6709 R2 \u547D\u4EE4\u53EF\u4EE5\u8FDB\u5165\u53D7\u63A7\u6267\u884C\u8BA1\u5212");
+  if (!assessment.guardedExecutionAvailable) {
+    throw invalid4("\u8BE5 R2 \u547D\u4EE4\u4E0D\u5728\u9996\u6279\u53D7\u63A7\u6267\u884C\u5668\u652F\u6301\u9762");
+  }
+  if (!assessment.environment.envAlias) throw invalid4("R2 argv \u5FC5\u987B\u663E\u5F0F\u5305\u542B --env \u73AF\u5883\u522B\u540D");
+  if (!assessment.environment.identityAlias) {
+    throw invalid4("R2 argv \u5FC5\u987B\u663E\u5F0F\u5305\u542B --as \u8EAB\u4EFD\u522B\u540D");
+  }
+  validateSupportedCommandShape(assessment.reasonCode, argv);
+}
+function validateSupportedCommandShape(reasonCode, argv) {
+  if (reasonCode === "record-create") {
+    requireFlagValue(argv, "--data", "create \u5FC5\u987B\u5305\u542B --data <JSON>");
+    return;
+  }
+  if (reasonCode === "record-update") {
+    requireFlagValue(argv, "--id", "update \u5FC5\u987B\u5305\u542B --id <id>");
+    requireFlagValue(argv, "--data", "update \u5FC5\u987B\u5305\u542B --data <JSON>");
+    return;
+  }
+  if (reasonCode === "cache-mutation") {
+    if (!argv[2] || argv[2].startsWith("-")) throw invalid4("cache clear \u5FC5\u987B\u5305\u542B Model");
+    return;
+  }
+  if (reasonCode === "setting-write") {
+    if (!argv[2] || argv[2].startsWith("-")) throw invalid4("setting \u5199\u547D\u4EE4\u5FC5\u987B\u5305\u542B domain");
+    if (argv[1] === "set") {
+      requireFlagValue(argv, "--set", "setting set \u5FC5\u987B\u5305\u542B --set <assignment>");
+      return;
+    }
+    if (argv[1] === "reset" && (!argv[3] || !argv[4])) {
+      throw invalid4("setting reset \u5FC5\u987B\u5305\u542B domain\u3001namespace \u4E0E key");
+    }
+  }
+}
+function requireFlagValue(argv, flag, message) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (value === flag) {
+      const next = argv[index + 1];
+      if (next && !next.startsWith("-")) return next;
+      throw invalid4(message);
+    }
+    if (value?.startsWith(`${flag}=`) && value.length > flag.length + 1) {
+      return value.slice(flag.length + 1);
+    }
+  }
+  throw invalid4(message);
+}
+function assertRuntimeMatches(actual, expected) {
+  if (canonicalJson(actual) !== canonicalJson(expected)) {
+    throw invalid4("\u5F53\u524D CLI \u8FD0\u884C\u65F6\u6458\u8981\u4E0E Chiron \u9501\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u91CD\u65B0 skills sync");
+  }
+}
+async function currentRuntimeIdentity() {
+  const entry = process.argv[1];
+  if (!entry) throw invalid4("\u65E0\u6CD5\u89E3\u6790\u5F53\u524D CLI entry");
+  return {
+    kind: "node-entry",
+    executableSha256: await sha256File2(process.execPath),
+    entrySha256: await sha256File2(entry)
+  };
+}
+async function runCurrentCliCommand(argv, cwd, streams) {
+  const entry = process.argv[1];
+  if (!entry) throw invalid4("\u65E0\u6CD5\u89E3\u6790\u5F53\u524D CLI entry");
+  return new Promise((resolve3, reject) => {
+    const child = spawn(process.execPath, [entry, ...argv], {
+      cwd,
+      env: process.env,
+      shell: false,
+      stdio: ["inherit", "pipe", "pipe"],
+      windowsHide: true
+    });
+    child.stdout.on("data", (chunk) => {
+      streams.stdout(chunk);
+      process.stdout.write(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      streams.stderr(chunk);
+      process.stderr.write(chunk);
+    });
+    child.once("error", reject);
+    child.once("close", (code, signal) => resolve3({ exitCode: code ?? (signal ? 1 : 0) }));
+  });
+}
+async function writeReceiptExclusive(target, receipt) {
+  const temp = `${target}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await fs7.writeFile(temp, `${JSON.stringify(receipt, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+    await fs7.link(temp, target);
+  } catch (cause) {
+    throw invalid4(`\u6267\u884C\u6536\u636E\u5199\u5165\u5931\u8D25\u6216\u5DF2\u5B58\u5728\uFF1A${path6.basename(target)}`, cause);
+  } finally {
+    await fs7.unlink(temp).catch(() => void 0);
+  }
+}
+async function safeManagedDirectory(project, relative2, absolute) {
+  await assertNoSymlinkComponents(project, path6.dirname(relative2));
+  const existing = await fs7.lstat(absolute).catch(() => void 0);
+  if (existing?.isSymbolicLink()) throw invalid4(`\u53D7\u7BA1\u76EE\u5F55\u4E0D\u80FD\u662F\u7B26\u53F7\u94FE\u63A5\uFF1A${relative2}`);
+  if (existing && !existing.isDirectory()) throw invalid4(`\u53D7\u7BA1\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55\uFF1A${relative2}`);
+  if (!existing) await fs7.mkdir(absolute, { mode: 448 });
+  await fs7.chmod(absolute, 448);
+}
+async function pathExists(file) {
+  return fs7.lstat(file).then(
+    () => true,
+    (cause) => {
+      if (cause.code === "ENOENT") return false;
+      throw cause;
+    }
+  );
+}
+async function readSafeFile(project, file, label) {
+  const relative2 = path6.relative(project, file).split(path6.sep).join("/");
+  if (relative2.startsWith("../") || path6.isAbsolute(relative2))
+    throw invalid4(`${label}\u8DEF\u5F84\u9003\u9038\u9879\u76EE`);
+  await assertNoSymlinkComponents(project, relative2);
+  let stat;
+  try {
+    stat = await fs7.lstat(file);
+  } catch (cause) {
+    throw invalid4(`${label}\u4E0D\u53EF\u7528\uFF1A${relative2}`, cause);
+  }
+  if (stat.isSymbolicLink()) throw invalid4(`${label}\u4E0D\u80FD\u662F\u7B26\u53F7\u94FE\u63A5\uFF1A${relative2}`);
+  if (!stat.isFile()) throw invalid4(`${label}\u4E0D\u662F\u666E\u901A\u6587\u4EF6\uFF1A${relative2}`);
+  return fs7.readFile(file);
+}
+async function assertNoSymlinkComponents(project, relative2) {
+  const parts = relative2.split("/").filter(Boolean);
+  let current = project;
+  for (const part of parts) {
+    current = path6.join(current, part);
+    const stat = await fs7.lstat(current).catch(() => void 0);
+    if (stat?.isSymbolicLink()) throw invalid4(`\u8DEF\u5F84\u5305\u542B\u7B26\u53F7\u94FE\u63A5\uFF1A${relative2}`);
+    if (!stat) break;
+  }
+}
+async function realProject(requested) {
+  const absolute = path6.resolve(requested);
+  let project;
+  try {
+    project = await fs7.realpath(absolute);
+  } catch (cause) {
+    throw invalid4(`\u9879\u76EE\u76EE\u5F55\u4E0D\u53EF\u7528\uFF1A${absolute}`, cause);
+  }
+  const stat = await fs7.stat(project);
+  if (!stat.isDirectory()) throw invalid4(`\u9879\u76EE\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55\uFF1A${absolute}`);
+  return project;
+}
+function safeRelative(reference, label) {
+  if (!reference || path6.isAbsolute(reference) || /[\r\n\0]/.test(reference)) {
+    throw invalid4(`${label}\u5FC5\u987B\u662F\u9879\u76EE\u5185\u76F8\u5BF9\u8DEF\u5F84`);
+  }
+  const normalized = path6.normalize(reference).split(path6.sep).join("/");
+  if (normalized === ".." || normalized.startsWith("../") || normalized === ".") {
+    throw invalid4(`${label}\u8DEF\u5F84\u9003\u9038\u9879\u76EE`);
+  }
+  return normalized.replace(/^\.\//, "");
+}
+function isRuntimeIdentity(value) {
+  if (!isRecord(value) || !isSha(value.executableSha256)) return false;
+  if (value.kind === "executable") return true;
+  return value.kind === "node-entry" && isSha(value.entrySha256);
+}
+function isExecutionPlan(value) {
+  if (!isRecord(value)) return false;
+  return value.schemaVersion === 1 && value.contractVersion === EXECUTION_CONTRACT_VERSION && typeof value.planId === "string" && PLAN_ID_PATTERN.test(value.planId) && typeof value.createdAt === "string" && typeof value.expiresAt === "string" && isSha(value.nonceSha256) && isSha(value.chironLockSha256) && isRuntimeIdentity(value.runtime) && isRecord(value.assessment) && isRecord(value.documents) && isBoundDocument(value.documents.change) && isBoundDocument(value.documents.rollback) && typeof value.evidenceDir === "string";
+}
+function isBoundDocument(value) {
+  return isRecord(value) && typeof value.path === "string" && isSha(value.sha256);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSha(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function parseTtl(value) {
+  if (value === void 0) return void 0;
+  if (!/^\d+$/.test(value)) throw invalid4("--ttl-seconds \u5FC5\u987B\u662F\u6574\u6570");
+  return Number(value);
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (isRecord(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function sha2566(value) {
+  return createHash6("sha256").update(value).digest("hex");
+}
+async function sha256File2(file) {
+  const hash = createHash6("sha256");
+  await new Promise((resolve3, reject) => {
+    const stream = createReadStream2(file);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", resolve3);
+  });
+  return hash.digest("hex");
+}
+function invalid4(message, cause) {
+  return new CliError20({ code: CliErrorCode19.INVALID_ARGUMENT, message, cause });
+}
+
+// src/startup.ts
+function needsLegacyProfileMigration(argv) {
+  const args = argv.slice(2);
+  if (args[0] === "delivery") return false;
+  return !args.some((arg) => ["--help", "-h", "--version", "-V"].includes(arg));
+}
+
 // src/index.ts
 var program = new Command();
 var exitOnBrokenPipe = (err) => {
@@ -6640,6 +8304,10 @@ var identity = program.command("identity").description("\u7BA1\u7406 HCM \u8EAB\
 identity.command("list").description("\u5217\u51FA identity\uFF08\u9ED8\u8BA4\u5217\u5F53\u524D env\uFF0C--env all \u5217\u5168\u90E8\uFF09").option("--env <name>", '\u8FC7\u6EE4 env\uFF1B\u4F20 "all" \u5217\u5168\u90E8', void 0).action((opts) => identityList(opts));
 identity.command("use <name>").description("\u628A identity \u8BBE\u4E3A\u5176 env \u7684 default identity").action((name) => identityUse(name));
 identity.command("remove <name>").description("\u5220\u9664 identity\uFF08\u6E05 token + \u82E5\u662F env default \u5219\u6E05\u7A7A\uFF09").action((name) => identityRemove(name));
+var delivery = program.command("delivery").description("\u987E\u95EE\u4EA4\u4ED8\u547D\u4EE4\u7684\u98CE\u9669\u8BC4\u4F30\u4E0E\u4E00\u6B21\u6027\u53D7\u63A7\u6267\u884C\u5408\u540C");
+delivery.command("assess").description("\u7EAF\u672C\u5730\u8BC4\u4F30\u4E00\u6B21 HCM CLI argv\uFF1B\u7528 -- \u5206\u9694\u88AB\u8BC4\u4F30\u547D\u4EE4").option("--output <fmt>", "\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "json").allowUnknownOption(true).argument("<command...>", "\u88AB\u8BC4\u4F30\u7684 HCM \u5B50\u547D\u4EE4\u4E0E\u53C2\u6570\uFF0C\u4E0D\u5305\u542B hcm \u672C\u8EAB").action((command, opts) => deliveryAssessCommand(command, opts));
+delivery.command("prepare").description("\u628A\u53D7\u652F\u6301\u7684 R2 argv \u4E0E\u9501\u3001\u8FD0\u884C\u65F6\u548C\u53D8\u66F4/\u56DE\u6EDA\u8BF4\u660E\u7ED1\u5B9A\u4E3A\u77ED\u65F6\u6267\u884C\u8BA1\u5212").requiredOption("--change-ref <file>", "\u9879\u76EE work/ \u6216 decisions/ \u4E0B\u7684\u53D8\u66F4\u8BF4\u660E").requiredOption("--rollback-ref <file>", "\u9879\u76EE work/ \u6216 decisions/ \u4E0B\u7684\u56DE\u6EDA\u8BF4\u660E").requiredOption("--evidence-dir <dir>", "\u9879\u76EE evidence/ \u4E0B\u7684\u6536\u636E\u76EE\u5F55").option("--project <dir>", "HCM \u987E\u95EE\u9879\u76EE\u6839\u76EE\u5F55", ".").option("--ttl-seconds <n>", "\u6709\u6548\u671F\u79D2\u6570\uFF0860-3600\uFF09", "900").option("--output <fmt>", "\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "json").allowUnknownOption(true).argument("<command...>", "\u88AB\u7ED1\u5B9A\u7684 R2 HCM \u5B50\u547D\u4EE4\u4E0E\u53C2\u6570\uFF0C\u4E0D\u5305\u542B hcm \u672C\u8EAB").action((command, opts) => deliveryPrepareCommand(command, opts));
+delivery.command("execute <planId>").description("\u9010\u6B21\u6279\u51C6\u540E\u6D88\u8D39\u77ED\u65F6\u8BA1\u5212\uFF0C\u5E76\u6267\u884C\u4E00\u6B21\u4E0E\u8BA1\u5212\u5B8C\u5168\u76F8\u540C\u7684 R2 argv").option("--project <dir>", "HCM \u987E\u95EE\u9879\u76EE\u6839\u76EE\u5F55", ".").option("--output <fmt>", "\u6536\u636E\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "json").allowUnknownOption(true).argument("<command...>", "\u4E0E prepare \u5B8C\u5168\u76F8\u540C\u7684 R2 HCM \u5B50\u547D\u4EE4\u4E0E\u53C2\u6570").action((planId, command, opts) => deliveryExecuteCommand(planId, command, opts));
 program.command("query <Model>").description("\u67E5\u8BE2 Model \u5217\u8868\u6570\u636E\uFF08\u901A\u8FC7 ModelQueryDsl JSON \u8868\u8FBE\u8FC7\u6EE4/\u6392\u5E8F/\u5206\u9875\uFF09").option(
   "--filter <JSON>",
   `\u8FC7\u6EE4 AST\uFF08ModelQueryDsl\uFF09\uFF1A\u53F6\u5B50 '{"field":"status","op":"eq","value":"ACTIVE"}'\uFF0C\u591A\u6761\u4EF6\u7528 '{"and":[\u53F6\u5B50,\u2026]}'\u3002\u26A0\uFE0F \u4E0D\u63A5\u53D7 {"\u5B57\u6BB5":"\u503C"} \u7B80\u5199\uFF0Cschema \u5C42\u4F1A\u62D2`
@@ -6703,6 +8371,7 @@ var skills = program.command("skills").description("\u777F\u620E Chiron \u4EA4\u
 skills.command("list [keyword]").description("\u5217\u51FA\u76EE\u6807\u73AF\u5883\u8FD9\u4E00\u7248\u7684\u4EA4\u4ED8\u6280\u80FD\uFF1B--installed \u6539\u770B\u672C\u5730\u88C5\u4E86\u54EA\u4E9B\uFF08\u4E0D\u8FDE\u7F51\uFF09").option("--installed", "\u53EA\u770B\u672C\u5730\u5DF2\u88C5\u7684\u6280\u80FD\uFF08\u8BFB .hcm-skills.json\uFF0C\u4E0D\u8FDE\u7F51\uFF09").option("--target <agent>", "\u914D\u5408 --installed\uFF1Aclaude | codex | auto", "auto").option("--global", "\u914D\u5408 --installed\uFF1A\u770B\u7528\u6237\u7EA7\u76EE\u5F55").option("--dir <path>", "\u914D\u5408 --installed\uFF1A\u770B\u6307\u5B9A\u76EE\u5F55").option("--category <key>", "\u53EA\u770B\u67D0\u4E2A\u5206\u7C7B").option("--stage <key>", "\u53EA\u770B\u67D0\u4E2A\u4EA4\u4ED8\u9636\u6BB5\uFF1Ahandover | baseline | configure | migrate | integrate | golive | operate").option("--by-stage", "\u6309\u4EA4\u4ED8\u751F\u547D\u5468\u671F\u5206\u7EC4\u5C55\u793A\uFF08\u9ED8\u8BA4\u6309\u529F\u80FD\u5206\u7C7B\uFF09").option("--endpoint <url>", "\u6280\u80FD\u5E93\u5730\u5740\uFF08\u9ED8\u8BA4\u53D6 activeEnv \u7684 endpoint\uFF09").option("--env <name>", "\u4ECE\u8BE5 env \u89E3\u6790 endpoint").option("--output <fmt>", "\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "table").action((kw, opts) => skillsListCommand(kw, opts));
 skills.command("show <id>").description("\u6253\u5370\u6280\u80FD\u539F\u6587\uFF08\u7BA1\u9053\u53CB\u597D\uFF09").option("--endpoint <url>", "\u6280\u80FD\u5E93\u5730\u5740\uFF08\u9ED8\u8BA4\u53D6 activeEnv \u7684 endpoint\uFF09").option("--env <name>", "\u4ECE\u8BE5 env \u89E3\u6790 endpoint").action((id, opts) => skillsShowCommand(id, opts));
 skills.command("install [id]").description("\u8FDE\u540C requires \u524D\u7F6E\u6280\u80FD\u4E0E\u53C2\u8003\u6587\u4EF6\u88C5\u5230 agent \u6280\u80FD\u76EE\u5F55\uFF1B--all \u88C5\u6574\u4E2A\u6280\u80FD\u5E93").option("--all", "\u88C5\u6574\u4E2A\u6280\u80FD\u5E93\uFF0C\u5E76\u8BB0\u4E3A\u300C\u8DDF\u968F\u5168\u96C6\u300D\uFF08\u5F80\u540E update \u4F1A\u81EA\u52A8\u8865\u4E0A\u4EA7\u54C1\u65B0\u589E\u7684\u6280\u80FD\uFF09").option("--target <agent>", "\u88C5\u7ED9\u54EA\u4E2A agent\uFF1Aclaude\uFF08.claude/skills/\uFF09| codex\uFF08hcm-skills/ + AGENTS.md\uFF09| auto", "auto").option("--global", "\u88C5\u5230\u7528\u6237\u7EA7\u76EE\u5F55\u800C\u975E\u5F53\u524D\u9879\u76EE").option("--dir <path>", "\u88C5\u5230\u6307\u5B9A\u76EE\u5F55").option("--from <dir>", "\u4ECE\u672C\u5730\u76EE\u5F55\u88C5\uFF08\u73B0\u573A\u6539\u8FC7\u7684\u7248\u672C\uFF09\uFF0C\u4E0D\u8D70\u7F51\u7EDC").option("--force", "\u8986\u76D6\u5DF2\u5B58\u5728\u7684\u540C\u540D\u6280\u80FD").option("--endpoint <url>", "\u6280\u80FD\u5E93\u5730\u5740\uFF08\u9ED8\u8BA4\u53D6 activeEnv \u7684 endpoint\uFF09").option("--env <name>", "\u4ECE\u8BE5 env \u89E3\u6790 endpoint").option("--output <fmt>", "\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "table").action((id, opts) => skillsInstallCommand(id, opts));
+skills.command("sync <id>").description("\u4ECE\u76EE\u6807\u5B9E\u4F8B\u540C\u6B65 Skill \u95ED\u5305\u5230 WorkBuddy \u9879\u76EE\u5E76\u5199 chiron.lock").requiredOption("--target <agent>", "\u76EE\u6807 Agent \u5BBF\u4E3B\uFF1B\u5F53\u524D\u652F\u6301 workbuddy").requiredOption("--project <path>", "WorkBuddy \u9879\u76EE\u6839\u76EE\u5F55").option("--cli <path>", "\u663E\u5F0F\u6307\u5B9A\u8981\u9501\u5B9A\u5230\u9879\u76EE\u7684 HCM CLI\uFF1B\u9ED8\u8BA4\u4F7F\u7528\u5F53\u524D\u8FD9\u4EFD CLI").option("--endpoint <url>", "\u6280\u80FD\u5E93\u5730\u5740\uFF08\u9ED8\u8BA4\u53D6 activeEnv \u7684 endpoint\uFF09").option("--env <name>", "\u4ECE\u8BE5 env \u89E3\u6790 endpoint").option("--output <fmt>", "\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "table").action((id, opts) => skillsSyncCommand(id, opts));
 skills.command("update").description("\u628A\u88C5\u8FC7\u7684\u6280\u80FD\u5347\u5230\u76EE\u6807\u73AF\u5883\u8FD9\u4E00\u7248\uFF08\u4EA7\u54C1\u5347\u7EA7\u540E\u8DD1\u5B83\uFF09").option("--all", "\u8FDE\u4EA7\u54C1\u65B0\u589E\u7684\u6280\u80FD\u4E00\u8D77\u88C5\u4E0A\uFF0C\u5E76\u8BB0\u4E3A\u300C\u8DDF\u968F\u5168\u96C6\u300D").option("--check", "\u53EA\u770B\u4F1A\u53D8\u4EC0\u4E48\uFF0C\u4E0D\u5199\u76D8").option("--target <agent>", "claude | codex | auto\uFF08\u9ED8\u8BA4\u6309\u5DF2\u5B89\u88C5\u76EE\u5F55\u63A2\uFF09", "auto").option("--global", "\u5347\u7EA7\u7528\u6237\u7EA7\u76EE\u5F55\u91CC\u7684\u6280\u80FD").option("--dir <path>", "\u5347\u7EA7\u6307\u5B9A\u76EE\u5F55\u91CC\u7684\u6280\u80FD").option("--force", "\u8FDE\u672C\u5730\u6539\u8FC7\u7684\u6280\u80FD\u4E00\u8D77\u8986\u76D6\u6210\u4EA7\u54C1\u8FD9\u4E00\u7248").option("--endpoint <url>", "\u6280\u80FD\u5E93\u5730\u5740\uFF08\u9ED8\u8BA4\u53D6\u5B89\u88C5\u65F6\u8BB0\u5F55\u7684\u5730\u5740\uFF09").option("--env <name>", "\u4ECE\u8BE5 env \u89E3\u6790 endpoint").option("--output <fmt>", "\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "table").action((opts) => skillsUpdateCommand(opts));
 program.command("update <Model>").description("\u66F4\u65B0\u4E00\u6761 Model \u8BB0\u5F55\uFF08\u8D70\u540E\u7AEF\u5B8C\u6574\u6821\u9A8C\uFF09").requiredOption("--id <id>", "\u8BB0\u5F55 ID").requiredOption("--data <JSON>", `\u8981\u66F4\u65B0\u7684\u5B57\u6BB5 JSON\uFF0C\u4F8B\u5982 '{"name":"\u65B0\u540D\u79F0"}'`).option("--env <name>", "\u4E34\u65F6\u5207\u73AF\u5883\uFF08\u8986\u76D6 activeEnv\uFF0C\u672C\u6B21\u547D\u4EE4\uFF09").option("--as <identity>", "\u4E34\u65F6\u6362\u8EAB\u4EFD\uFF08\u8986\u76D6 env defaultIdentity\uFF0C\u672C\u6B21\u547D\u4EE4\uFF09").option("--output <fmt>", "\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "json").action((model, opts) => updateCommand(model, opts));
 program.command("version").description("\u67E5\u540E\u7AEF\u7248\u672C\uFF08commit / tag / \u6784\u5EFA\u65F6\u95F4\uFF09\u2014\u2014\u514D\u8BA4\u8BC1\uFF0C\u65E0\u9700\u5148 login").option("--endpoint <url>", "\u540E\u7AEF\u5730\u5740\uFF08\u9ED8\u8BA4\u53D6 activeEnv \u7684 endpoint\uFF09").option("--env <name>", "\u4ECE\u8BE5 env \u89E3\u6790 endpoint").option("--output <fmt>", "\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "json").action((opts) => versionCommand(opts));
@@ -6711,13 +8380,15 @@ setting.command("get <domain>").description("\u8BFB\u67D0\u57DF\u53C2\u6570\uFF0
 setting.command("set <domain>").description("\u6539\u53C2\u6570\uFF0C\u53EF\u91CD\u590D --set\uFF1B\u8D70\u53D7\u63A7\u6821\u9A8C\u8DEF\u5F84\u800C\u975E\u6807\u51C6 CRUD").option("--set <assignment...>", "namespace.key=value\uFF0C\u4F8B\u5982 security.password.passwordPolicy=complex").option("--dry-run", "\u53EA\u663E\u793A\u5C06\u5199\u5165\u4EC0\u4E48\uFF0C\u4E0D\u5B9E\u9645\u5199\u5165").option("--env <name>", "\u4E34\u65F6\u5207\u73AF\u5883\uFF08\u8986\u76D6 activeEnv\uFF0C\u672C\u6B21\u547D\u4EE4\uFF09").option("--as <identity>", "\u4E34\u65F6\u6362\u8EAB\u4EFD").option("--output <fmt>", "\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "json").action((d, opts) => settingSetCommand(d, opts));
 setting.command("reset <domain> <namespace> <key>").description("\u6E05\u9664\u79DF\u6237\u8986\u76D6\uFF0C\u56DE\u843D\u5230\u9ED8\u8BA4\u503C").option("--revision <n>", "\u4E50\u89C2\u9501\u7248\u672C\u53F7").option("-y, --yes", "\u8DF3\u8FC7\u786E\u8BA4").option("--env <name>", "\u4E34\u65F6\u5207\u73AF\u5883\uFF08\u8986\u76D6 activeEnv\uFF0C\u672C\u6B21\u547D\u4EE4\uFF09").option("--as <identity>", "\u4E34\u65F6\u6362\u8EAB\u4EFD").option("--output <fmt>", "\u8F93\u51FA\u683C\u5F0F\uFF1Atable | json | yaml", "json").action((d, ns, k, opts) => settingResetCommand(d, ns, k, opts));
 async function main() {
-  try {
-    await migrateLegacyProfiles();
-  } catch (e) {
-    process.stderr.write(
-      `[hcm] event=migration_error reason=${JSON.stringify(String(e.message))}
+  if (needsLegacyProfileMigration(process.argv)) {
+    try {
+      await migrateLegacyProfiles();
+    } catch (e) {
+      process.stderr.write(
+        `[hcm] event=migration_error reason=${JSON.stringify(String(e.message))}
 `
-    );
+      );
+    }
   }
   await program.parseAsync(process.argv);
 }