ai-project-manage-cli 7.0.2 → 7.0.3

package/dist/index.js

@@ -83,8 +83,8 @@ function buildAgentWsUrl(httpBase, apiKey) {
 }
 
 // src/commands/init.ts
-import { join as join5 } from "path";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join7 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
 
 // src/command-utils.ts
 import {
@@ -113,8 +113,8 @@ function toFsPath(inputPath) {
   }
   return `\\\\?\\${normalized}`;
 }
-function normalizeWorkdirPath(path10) {
-  let normalized = path10.trim().replace(/\\/g, "/").normalize("NFC");
+function normalizeWorkdirPath(path13) {
+  let normalized = path13.trim().replace(/\\/g, "/").normalize("NFC");
   if (normalized.startsWith("//?/")) {
     normalized = normalized.slice(4);
   }
@@ -297,9 +297,9 @@ function assertTemplateCopiedToApm(apmDir, workdir) {
     "project"
   ];
   for (const item of required) {
-    const path10 = join2(apmDir, item);
-    if (!existsSync2(toFsPath(path10))) {
-      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path10}`);
+    const path13 = join2(apmDir, item);
+    if (!existsSync2(toFsPath(path13))) {
+      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path13}`);
     }
   }
   const leakedRules = join2(workdir, "rules");
@@ -348,9 +348,6 @@ function taskDir(taskId, apmRoot, workdir) {
 function taskDocsDir(taskId, apmRoot, workdir) {
   return join2(taskDir(taskId, apmRoot, workdir), TASK_DOCS_SUBDIR);
 }
-function taskRulePath(taskId, apmRoot, workdir) {
-  return join2(taskDir(taskId, apmRoot, workdir), "RULE.md");
-}
 function taskTaskPath(taskId, apmRoot, workdir) {
   return join2(taskDir(taskId, apmRoot, workdir), "TASK.md");
 }
@@ -574,66 +571,170 @@ ${diagnostic ?? ""}
 
 // src/repository-project-documents-sync.ts
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   rmSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
-import { dirname as dirname2, join as join4, relative, sep } from "path";
-var MANIFEST_FILE = "manifest.json";
-function projectDocumentsDir(apmRoot) {
-  return join4(apmRoot ?? workspaceApmDir(), "project");
+import { dirname as dirname2, join as join5, relative, sep } from "path";
+
+// src/apm-manifest.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+var APM_MANIFEST_FILE = "manifest.json";
+var LEGACY_PROJECT_MANIFEST = join4("project", APM_MANIFEST_FILE);
+function apmManifestPath(apmRoot) {
+  return join4(apmRoot, APM_MANIFEST_FILE);
 }
-function projectDocumentLocalPath(apmRoot, documentPath) {
-  const normalized = normalizeLocalDocumentPath(documentPath);
-  return join4(projectDocumentsDir(apmRoot), ...normalized.split("/"));
+function hashApmFileContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
 }
-function normalizeLocalDocumentPath(path10) {
-  const trimmed = path10.trim().replace(/\\/g, "/");
-  if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path10}`);
-  }
-  const segments = trimmed.split("/").filter(Boolean);
-  if (segments.some((segment) => segment === ".." || segment === ".")) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path10}`);
+function toProjectManifestPath(localPath) {
+  const trimmed = localPath.trim().replace(/\\/g, "/");
+  return `project/${trimmed}`;
+}
+function fromProjectManifestPath(manifestPath) {
+  const prefix = "project/";
+  if (!manifestPath.startsWith(prefix)) {
+    throw new Error(`\u975E\u6CD5\u9879\u76EE\u6587\u6863 manifest \u8DEF\u5F84: ${manifestPath}`);
   }
-  return segments.join("/");
+  return manifestPath.slice(prefix.length);
+}
+function toRuleManifestPath(fileName) {
+  return `rules/${fileName}`;
+}
+function toSkillManifestPath(skillDirName) {
+  return `skills/${skillDirName}/SKILL.md`;
 }
-function readLocalManifest(apmRoot) {
-  const manifestPath = join4(projectDocumentsDir(apmRoot), MANIFEST_FILE);
-  if (!existsSync3(manifestPath)) {
+function manifestSectionPrefix(section) {
+  return `${section}/`;
+}
+function readApmManifest(apmRoot) {
+  const primary = apmManifestPath(apmRoot);
+  if (existsSync3(toFsPath(primary))) {
+    return parseApmManifest(readFileSync3(toFsPath(primary), "utf8"));
+  }
+  const legacy = join4(apmRoot, LEGACY_PROJECT_MANIFEST);
+  if (!existsSync3(toFsPath(legacy))) {
+    return null;
+  }
+  const legacyManifest = parseApmManifest(readFileSync3(toFsPath(legacy), "utf8"));
+  if (!legacyManifest) {
     return null;
   }
+  return {
+    ...legacyManifest,
+    documents: legacyManifest.documents.map((entry) => ({
+      ...entry,
+      path: entry.path.startsWith("project/") ? entry.path : toProjectManifestPath(entry.path)
+    }))
+  };
+}
+function parseApmManifest(raw) {
   try {
-    return JSON.parse(
-      readFileSync3(manifestPath, "utf8")
-    );
+    const parsed = JSON.parse(raw);
+    if (parsed?.version === 1 && Array.isArray(parsed.documents) && (parsed.repositoryId === null || typeof parsed.repositoryId === "string")) {
+      return parsed;
+    }
   } catch {
-    return null;
   }
+  return null;
 }
-function diffManifestPaths(remote, local) {
+function writeApmManifest(apmRoot, manifest) {
+  writeFileSync4(
+    toFsPath(apmManifestPath(apmRoot)),
+    `${JSON.stringify(
+      {
+        ...manifest,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        documents: [...manifest.documents].sort(
+          (a, b) => a.path.localeCompare(b.path)
+        )
+      },
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+}
+function mergeManifestSection(manifest, section, entries, repositoryId) {
+  const prefix = manifestSectionPrefix(section);
+  const kept = (manifest?.documents ?? []).filter(
+    (entry) => !entry.path.startsWith(prefix)
+  );
+  return {
+    version: 1,
+    repositoryId: repositoryId !== void 0 ? repositoryId : manifest?.repositoryId ?? null,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    documents: [...kept, ...entries]
+  };
+}
+function buildManifestEntryFromFile(input) {
+  return {
+    path: input.path,
+    description: input.description ?? null,
+    contentHash: hashApmFileContent(input.content),
+    updatedAt: input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    size: Buffer.byteLength(input.content, "utf8"),
+    ...input.remoteId ? { remoteId: input.remoteId } : {}
+  };
+}
+function diffManifestPaths(remote, local, section) {
+  const prefix = manifestSectionPrefix(section);
   const remoteMap = new Map(
-    (remote?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
+    (remote?.documents ?? []).filter((doc) => doc.path.startsWith(prefix)).map((doc) => [doc.path, doc.contentHash])
   );
   const localMap = new Map(
-    (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
+    (local?.documents ?? []).filter((doc) => doc.path.startsWith(prefix)).map((doc) => [doc.path, doc.contentHash])
   );
   const download = [];
-  for (const [path10, hash] of remoteMap) {
-    if (localMap.get(path10) !== hash) {
-      download.push(path10);
+  for (const [path13, hash] of remoteMap) {
+    if (localMap.get(path13) !== hash) {
+      download.push(path13);
     }
   }
   const deleteLocal = [];
-  for (const path10 of localMap.keys()) {
-    if (!remoteMap.has(path10)) {
-      deleteLocal.push(path10);
+  for (const path13 of localMap.keys()) {
+    if (!remoteMap.has(path13)) {
+      deleteLocal.push(path13);
     }
   }
   return { download, deleteLocal };
 }
+
+// src/repository-project-documents-sync.ts
+function projectDocumentsDir(apmRoot) {
+  return join5(apmRoot ?? workspaceApmDir(), "project");
+}
+function projectDocumentLocalPath(apmRoot, documentPath) {
+  const normalized = normalizeLocalDocumentPath(documentPath);
+  return join5(projectDocumentsDir(apmRoot), ...normalized.split("/"));
+}
+function normalizeLocalDocumentPath(path13) {
+  const trimmed = path13.trim().replace(/\\/g, "/");
+  if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path13}`);
+  }
+  const segments = trimmed.split("/").filter(Boolean);
+  if (segments.some((segment) => segment === ".." || segment === ".")) {
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path13}`);
+  }
+  return segments.join("/");
+}
+function toRemoteProjectManifest(repositoryId, remoteManifest) {
+  return {
+    version: 1,
+    repositoryId,
+    generatedAt: remoteManifest.generatedAt,
+    documents: remoteManifest.documents.map((doc) => ({
+      ...doc,
+      path: toProjectManifestPath(doc.path)
+    }))
+  };
+}
 async function syncRepositoryProjectDocumentsPull(workdirPath, apmDir) {
   const empty = {
     synced: false,
@@ -654,10 +755,8 @@ async function syncRepositoryProjectDocumentsPull(workdirPath, apmDir) {
     workdirPath
   );
   if (!repositoryId) {
-    console.log(
-      `[apm] \u672A\u80FD\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u3002
-${diagnostic ?? ""}`
-    );
+    console.log(`[apm] \u672A\u80FD\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u3002
+${diagnostic ?? ""}`);
     return empty;
   }
   const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
@@ -665,43 +764,54 @@ ${diagnostic ?? ""}`
   await ensureDirExists(projectDir);
   const { manifest: remoteManifest } = await api.cli.getRepositoryProjectDocumentManifest({ repositoryId });
   if (!remoteManifest) {
-    console.log(
-      `[apm] \u4ED3\u5E93 ${repositoryId} \u65E0\u9879\u76EE\u6587\u6863 manifest\uFF0C\u8DF3\u8FC7\u540C\u6B65\u3002`
-    );
+    console.log(`[apm] \u4ED3\u5E93 ${repositoryId} \u65E0\u9879\u76EE\u6587\u6863 manifest\uFF0C\u8DF3\u8FC7\u540C\u6B65\u3002`);
     return { ...empty, repositoryId };
   }
-  const localManifest = readLocalManifest(targetApmDir);
+  const remoteApmManifest = toRemoteProjectManifest(
+    repositoryId,
+    remoteManifest
+  );
+  const localManifest = readApmManifest(targetApmDir);
   const { download, deleteLocal } = diffManifestPaths(
-    remoteManifest,
-    localManifest
+    remoteApmManifest,
+    localManifest,
+    "project"
   );
   let downloaded = 0;
   if (download.length > 0) {
     const { list } = await api.cli.listRepositoryProjectDocuments({
       repositoryId,
-      paths: download.join(",")
+      paths: download.map(fromProjectManifestPath).join(",")
     });
     for (const doc of list) {
-      const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, doc.path));
+      const absPath = toFsPath(
+        projectDocumentLocalPath(targetApmDir, doc.path)
+      );
       await ensureDirExists(dirname2(absPath));
-      writeFileSync4(absPath, doc.content, "utf8");
+      writeFileSync5(absPath, doc.content, "utf8");
       downloaded += 1;
     }
   }
   let deleted = 0;
-  for (const path10 of deleteLocal) {
-    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path10));
-    if (existsSync3(absPath)) {
+  for (const manifestPath of deleteLocal) {
+    const absPath = toFsPath(
+      projectDocumentLocalPath(
+        targetApmDir,
+        fromProjectManifestPath(manifestPath)
+      )
+    );
+    if (existsSync4(absPath)) {
       rmSync(absPath, { force: true });
       deleted += 1;
     }
   }
-  writeFileSync4(
-    toFsPath(join4(projectDir, MANIFEST_FILE)),
-    `${JSON.stringify(remoteManifest, null, 2)}
-`,
-    "utf8"
+  const nextManifest = mergeManifestSection(
+    localManifest,
+    "project",
+    remoteApmManifest.documents,
+    repositoryId
   );
+  writeApmManifest(targetApmDir, nextManifest);
   console.log(
     `[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: \u4E0B\u8F7D ${downloaded}\uFF0C\u5220\u9664\u672C\u5730 ${deleted}`
   );
@@ -713,6 +823,162 @@ ${diagnostic ?? ""}`
   };
 }
 
+// src/skills-sync.ts
+import {
+  copyFileSync as copyFileSync2,
+  cpSync,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync5,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { join as join6 } from "path";
+var AGENTS_TEMPLATE_PATH = join6(CLI_TEMPLATE_DIR, "AGENTS.md");
+var BASE_SKILLS_TEMPLATE_DIR = join6(CLI_TEMPLATE_DIR, "skills");
+var BASE_RULES_TEMPLATE_DIR = join6(CLI_TEMPLATE_DIR, "rules");
+function sanitizeSkillDirName(name) {
+  const trimmed = name.trim();
+  if (!trimmed) return "skill";
+  return trimmed.replace(/[/\\:*?"<>|]/g, "_");
+}
+function listBaseSkillDirNames() {
+  if (!existsSync5(BASE_SKILLS_TEMPLATE_DIR)) return [];
+  return readdirSync3(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
+    const path13 = join6(BASE_SKILLS_TEMPLATE_DIR, name);
+    return statSync2(path13).isDirectory();
+  });
+}
+function syncAgentsGuide(apmDir) {
+  if (!existsSync5(AGENTS_TEMPLATE_PATH)) return false;
+  mkdirSync3(apmDir, { recursive: true });
+  copyFileSync2(AGENTS_TEMPLATE_PATH, join6(apmDir, "AGENTS.md"));
+  return true;
+}
+function listBaseRuleFileNames() {
+  if (!existsSync5(BASE_RULES_TEMPLATE_DIR)) return [];
+  return readdirSync3(BASE_RULES_TEMPLATE_DIR).filter((name) => {
+    const path13 = join6(BASE_RULES_TEMPLATE_DIR, name);
+    return statSync2(path13).isFile();
+  });
+}
+function syncBaseRules(rulesDir) {
+  mkdirSync3(rulesDir, { recursive: true });
+  const names = listBaseRuleFileNames();
+  for (const name of names) {
+    const src = join6(BASE_RULES_TEMPLATE_DIR, name);
+    const dest = join6(rulesDir, name);
+    copyFileSync2(src, dest);
+  }
+  return names;
+}
+function syncBaseSkills(skillsDir) {
+  mkdirSync3(skillsDir, { recursive: true });
+  const names = listBaseSkillDirNames();
+  for (const name of names) {
+    const src = join6(BASE_SKILLS_TEMPLATE_DIR, name);
+    const dest = join6(skillsDir, name);
+    cpSync(src, dest, { recursive: true, force: true });
+  }
+  return names;
+}
+function syncSupplementarySkills(skillsDir, list) {
+  const baseNames = new Set(listBaseSkillDirNames());
+  const apiDirNames = /* @__PURE__ */ new Set();
+  const written = [];
+  const skipped = [];
+  for (const skill of list) {
+    const dirName = sanitizeSkillDirName(skill.name);
+    apiDirNames.add(dirName);
+    if (baseNames.has(dirName)) {
+      skipped.push(dirName);
+      continue;
+    }
+    const skillDir = join6(skillsDir, dirName);
+    mkdirSync3(skillDir, { recursive: true });
+    writeFileSync6(join6(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
+    written.push(dirName);
+  }
+  const removed = [];
+  if (!existsSync5(skillsDir)) return { written, skipped, removed };
+  for (const entry of readdirSync3(skillsDir)) {
+    const full = join6(skillsDir, entry);
+    if (!statSync2(full).isDirectory()) continue;
+    if (baseNames.has(entry)) continue;
+    if (apiDirNames.has(entry)) continue;
+    rmSync2(full, { recursive: true, force: true });
+    removed.push(entry);
+  }
+  return { written, skipped, removed };
+}
+function syncSkillsManifest(apmDir, supplementarySkills = []) {
+  const skillsDir = join6(apmDir, "skills");
+  if (!existsSync5(skillsDir)) {
+    return;
+  }
+  const supplementaryByDir = new Map(
+    supplementarySkills.map((skill) => [
+      sanitizeSkillDirName(skill.name),
+      skill
+    ])
+  );
+  const manifest = readApmManifest(apmDir);
+  const existingByPath = new Map(
+    (manifest?.documents ?? []).filter((entry) => entry.path.startsWith("skills/")).map((entry) => [entry.path, entry])
+  );
+  const entries = [];
+  for (const entry of readdirSync3(skillsDir)) {
+    const skillDir = join6(skillsDir, entry);
+    if (!statSync2(skillDir).isDirectory()) continue;
+    const skillFile = join6(skillDir, "SKILL.md");
+    if (!existsSync5(skillFile)) continue;
+    const content = readFileSync5(skillFile, "utf8");
+    const supplementary = supplementaryByDir.get(entry);
+    const manifestPath = toSkillManifestPath(entry);
+    const existing = existingByPath.get(manifestPath);
+    entries.push(
+      buildManifestEntryFromFile({
+        path: manifestPath,
+        content,
+        description: supplementary?.description ?? existing?.description ?? null,
+        remoteId: supplementary?.id ?? existing?.remoteId
+      })
+    );
+  }
+  writeApmManifest(apmDir, mergeManifestSection(manifest, "skills", entries));
+}
+function syncRulesManifest(apmDir) {
+  const rulesDir = join6(apmDir, "rules");
+  if (!existsSync5(rulesDir)) {
+    return;
+  }
+  const manifest = readApmManifest(apmDir);
+  const existingByPath = new Map(
+    (manifest?.documents ?? []).filter((entry) => entry.path.startsWith("rules/")).map((entry) => [entry.path, entry])
+  );
+  const entries = [];
+  for (const fileName of readdirSync3(rulesDir)) {
+    const dest = join6(rulesDir, fileName);
+    if (!statSync2(dest).isFile()) continue;
+    if (fileName === ".rules-sync-manifest.json") continue;
+    const manifestPath = toRuleManifestPath(fileName);
+    const content = readFileSync5(dest, "utf8");
+    const existing = existingByPath.get(manifestPath);
+    entries.push(
+      buildManifestEntryFromFile({
+        path: manifestPath,
+        content,
+        description: existing?.description ?? null,
+        updatedAt: existing?.updatedAt,
+        remoteId: existing?.remoteId
+      })
+    );
+  }
+  writeApmManifest(apmDir, mergeManifestSection(manifest, "rules", entries));
+}
+
 // src/git-utils.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -789,15 +1055,17 @@ async function ensureWorkspaceInitialized(workdir, options) {
   }
   const apmDir = workspaceApmDir(workdir);
   await copyTemplateFiles(apmDir, workdir);
+  syncRulesManifest(apmDir);
+  syncSkillsManifest(apmDir);
   const syncResult = await syncRemoteDeploymentConfig(workdir, apmDir);
   await syncRepositoryProjectDocumentsPull(workdir, apmDir);
   const trimmedName = options?.name?.trim();
   if (trimmedName) {
-    const apmConfigPath = toFsPath(join5(apmDir, "apm.config.json"));
-    const config = readFileSync4(apmConfigPath, "utf8");
+    const apmConfigPath = toFsPath(join7(apmDir, "apm.config.json"));
+    const config = readFileSync6(apmConfigPath, "utf8");
     const configJson = JSON.parse(config);
     configJson.name = trimmedName;
-    writeFileSync5(
+    writeFileSync7(
       apmConfigPath,
       `${JSON.stringify(configJson, null, 2)}
 `,
@@ -886,15 +1154,15 @@ async function runLogin(opts) {
 import { spawnSync } from "child_process";
 
 // src/version.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname3, join as join6 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname3, join as join8 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var CLI_PACKAGE_NAME = "ai-project-manage-cli";
 function readCliVersion() {
   try {
     const dir = dirname3(fileURLToPath2(import.meta.url));
-    const pkgPath = join6(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
+    const pkgPath = join8(dir, "..", "package.json");
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -967,104 +1235,12 @@ async function runUpdate() {
 }
 
 // src/commands/update-skills.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
-import { join as join8 } from "path";
-
-// src/skills-sync.ts
-import {
-  copyFileSync as copyFileSync2,
-  cpSync,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  readdirSync as readdirSync3,
-  rmSync as rmSync2,
-  statSync as statSync2,
-  writeFileSync as writeFileSync6
-} from "fs";
-import { join as join7 } from "path";
-var AGENTS_TEMPLATE_PATH = join7(CLI_TEMPLATE_DIR, "AGENTS.md");
-var BASE_SKILLS_TEMPLATE_DIR = join7(CLI_TEMPLATE_DIR, "skills");
-var BASE_RULES_TEMPLATE_DIR = join7(CLI_TEMPLATE_DIR, "rules");
-function sanitizeSkillDirName(name) {
-  const trimmed = name.trim();
-  if (!trimmed) return "skill";
-  return trimmed.replace(/[/\\:*?"<>|]/g, "_");
-}
-function listBaseSkillDirNames() {
-  if (!existsSync4(BASE_SKILLS_TEMPLATE_DIR)) return [];
-  return readdirSync3(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
-    const path10 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
-    return statSync2(path10).isDirectory();
-  });
-}
-function syncAgentsGuide(apmDir) {
-  if (!existsSync4(AGENTS_TEMPLATE_PATH)) return false;
-  mkdirSync3(apmDir, { recursive: true });
-  copyFileSync2(AGENTS_TEMPLATE_PATH, join7(apmDir, "AGENTS.md"));
-  return true;
-}
-function listBaseRuleFileNames() {
-  if (!existsSync4(BASE_RULES_TEMPLATE_DIR)) return [];
-  return readdirSync3(BASE_RULES_TEMPLATE_DIR).filter((name) => {
-    const path10 = join7(BASE_RULES_TEMPLATE_DIR, name);
-    return statSync2(path10).isFile();
-  });
-}
-function syncBaseRules(rulesDir) {
-  mkdirSync3(rulesDir, { recursive: true });
-  const names = listBaseRuleFileNames();
-  for (const name of names) {
-    const src = join7(BASE_RULES_TEMPLATE_DIR, name);
-    const dest = join7(rulesDir, name);
-    copyFileSync2(src, dest);
-  }
-  return names;
-}
-function syncBaseSkills(skillsDir) {
-  mkdirSync3(skillsDir, { recursive: true });
-  const names = listBaseSkillDirNames();
-  for (const name of names) {
-    const src = join7(BASE_SKILLS_TEMPLATE_DIR, name);
-    const dest = join7(skillsDir, name);
-    cpSync(src, dest, { recursive: true, force: true });
-  }
-  return names;
-}
-function syncSupplementarySkills(skillsDir, list) {
-  const baseNames = new Set(listBaseSkillDirNames());
-  const apiDirNames = /* @__PURE__ */ new Set();
-  const written = [];
-  const skipped = [];
-  for (const skill of list) {
-    const dirName = sanitizeSkillDirName(skill.name);
-    apiDirNames.add(dirName);
-    if (baseNames.has(dirName)) {
-      skipped.push(dirName);
-      continue;
-    }
-    const skillDir = join7(skillsDir, dirName);
-    mkdirSync3(skillDir, { recursive: true });
-    writeFileSync6(join7(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
-    written.push(dirName);
-  }
-  const removed = [];
-  if (!existsSync4(skillsDir)) return { written, skipped, removed };
-  for (const entry of readdirSync3(skillsDir)) {
-    const full = join7(skillsDir, entry);
-    if (!statSync2(full).isDirectory()) continue;
-    if (baseNames.has(entry)) continue;
-    if (apiDirNames.has(entry)) continue;
-    rmSync2(full, { recursive: true, force: true });
-    removed.push(entry);
-  }
-  return { written, skipped, removed };
-}
-
-// src/commands/update-skills.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
+import { join as join9 } from "path";
 async function syncWorkspaceSkills(cfg, workdir) {
   const apmDir = workspaceApmDir(workdir);
   const fsApmDir = toFsPath(apmDir);
-  if (!existsSync5(fsApmDir)) {
+  if (!existsSync6(fsApmDir)) {
     throw new Error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
   }
   const apmStat = statSync3(fsApmDir);
@@ -1076,12 +1252,13 @@ async function syncWorkspaceSkills(cfg, workdir) {
   if (syncAgentsGuide(apmDir)) {
     console.log("[apm] \u5DF2\u540C\u6B65 APM \u6307\u5357: .apm/AGENTS.md");
   }
-  const rulesDir = join8(apmDir, "rules");
+  const rulesDir = join9(apmDir, "rules");
   const ruleNames = syncBaseRules(rulesDir);
   for (const name of ruleNames) {
     console.log(`[apm] \u5DF2\u540C\u6B65\u57FA\u7840\u89C4\u5219: rules/${name}`);
   }
-  const skillsDir = join8(apmDir, "skills");
+  syncRulesManifest(apmDir);
+  const skillsDir = join9(apmDir, "skills");
   mkdirSync4(toFsPath(skillsDir), { recursive: true });
   const baseNames = syncBaseSkills(skillsDir);
   for (const name of baseNames) {
@@ -1102,13 +1279,14 @@ async function syncWorkspaceSkills(cfg, workdir) {
   for (const name of removed) {
     console.log(`[apm] \u5DF2\u79FB\u9664\u5DF2\u4E0B\u7EBF\u7684\u8865\u5145\u6280\u80FD: skills/${name}/`);
   }
+  syncSkillsManifest(apmDir, list);
   console.log(
     `[apm] \u540C\u6B65\u5B8C\u6210\uFF1A${ruleNames.length} \u4E2A\u57FA\u7840\u89C4\u5219\uFF0C${baseNames.length} \u4E2A\u57FA\u7840\u6280\u80FD\uFF0C${written.length} \u4E2A\u8865\u5145\u6280\u80FD`
   );
 }
 async function runUpdateSkills() {
   const apmDir = workspaceApmDir();
-  if (!existsSync5(apmDir)) {
+  if (!existsSync6(apmDir)) {
     console.error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
     process.exit(1);
   }
@@ -1121,7 +1299,7 @@ async function runUpdateSkills() {
 }
 
 // src/commands/connect.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import WebSocket from "ws";
 
 // src/ws/protocol.ts
@@ -1212,15 +1390,104 @@ function validateAgentWsMessage(value, kind) {
   return validateReceivedMailPush(o);
 }
 
-// src/commands/connect/deploy-run.ts
-import { spawn } from "node:child_process";
-import { readFileSync as readFileSync6 } from "node:fs";
-import { join as join9 } from "node:path";
+// src/commands/deploy/internal/deploy-log-syncer.ts
 var DEPLOY_LOG_SYNC_INTERVAL_MS = 3e4;
+function createDeployLogSyncer(api, deploymentRunId) {
+  let lastSyncedLog = "";
+  let latestLog = "";
+  const syncIfChanged = async () => {
+    if (!latestLog || latestLog === lastSyncedLog) {
+      return;
+    }
+    await api.cli.syncTaskDeploymentLog({
+      id: deploymentRunId,
+      log: latestLog
+    });
+    lastSyncedLog = latestLog;
+  };
+  const timer = setInterval(() => {
+    void syncIfChanged().catch((error) => {
+      console.error(
+        "[apm] deploy log sync failed:",
+        error instanceof Error ? error.message : String(error)
+      );
+    });
+  }, DEPLOY_LOG_SYNC_INTERVAL_MS);
+  return {
+    updateLog(log2) {
+      latestLog = log2;
+    },
+    async flush() {
+      clearInterval(timer);
+      await syncIfChanged();
+    },
+    dispose() {
+      clearInterval(timer);
+    }
+  };
+}
+
+// src/commands/deploy/internal/deploy-shell.ts
+import { spawn as spawn2 } from "node:child_process";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { join as join10 } from "node:path";
+
+// src/commands/deploy/internal/shell-exec.ts
+import {
+  spawn,
+  spawnSync as spawnSync2
+} from "node:child_process";
+import { platform as platform2 } from "node:os";
+function spawnShellOptions() {
+  if (platform2() === "win32") {
+    return {
+      shell: process.env.ComSpec ?? "cmd.exe",
+      windowsHide: true
+    };
+  }
+  return { shell: true, windowsHide: true };
+}
+function terminateChildProcess(child) {
+  try {
+    if (platform2() === "win32") {
+      child.kill();
+    } else {
+      child.kill("SIGTERM");
+    }
+  } catch {
+  }
+}
+function normalizeMavenLocalRepoPath(repoPath) {
+  return repoPath.replace(/\\/g, "/");
+}
+function quoteShellArg(value) {
+  if (!/\s/.test(value)) {
+    return value;
+  }
+  if (platform2() === "win32") {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function expandUserHomePath(pathStr) {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return pathStr.replace(/^~(?=$|[\\/])/, home);
+}
+function spawnSyncShellCommand(command, options = {}) {
+  return spawnSync2(command, {
+    ...options,
+    ...spawnShellOptions()
+  });
+}
+
+// src/commands/deploy/internal/deploy-shell.ts
+function isDeployEnvironment(value) {
+  return value === "test" || value === "online";
+}
 function readDeployConfig(workdir) {
-  const configPath = join9(workspaceApmDir(workdir), "apm.config.json");
+  const configPath = join10(workspaceApmDir(workdir), "apm.config.json");
   try {
-    const raw = readFileSync6(configPath, "utf8");
+    const raw = readFileSync8(configPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.deploy;
   } catch {
@@ -1240,88 +1507,91 @@ function missingDeployCommandMessage(environment) {
 function buildDeployLog(stdout, stderr) {
   return [stdout, stderr].filter(Boolean).join("\n");
 }
-function runShellCommand(command, cwd, signal, onOutput) {
+async function runDeployShellCommand(command, cwd, options) {
+  const signal = options?.signal ?? new AbortController().signal;
+  const shellOpts = spawnShellOptions();
+  if (options?.inheritStdio) {
+    return new Promise((resolve5, reject) => {
+      const child = spawn2(command, {
+        cwd,
+        env: process.env,
+        stdio: "inherit",
+        ...shellOpts
+      });
+      const onAbort = () => {
+        terminateChildProcess(child);
+      };
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      child.on("error", (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      });
+      child.on("close", (code) => {
+        signal.removeEventListener("abort", onAbort);
+        if (code === 0) {
+          resolve5({ log: "" });
+          return;
+        }
+        reject(new Error(`\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${code ?? "unknown"}: ${command}`));
+      });
+    });
+  }
   return new Promise((resolve5, reject) => {
-    const child = spawn(command, {
+    const child = spawn2(command, {
       cwd,
-      shell: true,
       env: process.env,
-      windowsHide: true
+      ...shellOpts
     });
     let stdout = "";
     let stderr = "";
     const emitLog = () => {
-      onOutput?.(buildDeployLog(stdout, stderr));
+      options?.onOutput?.(buildDeployLog(stdout, stderr));
     };
     const onAbort = () => {
-      child.kill("SIGTERM");
+      terminateChildProcess(child);
     };
     if (signal.aborted) {
       onAbort();
     } else {
       signal.addEventListener("abort", onAbort, { once: true });
     }
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-      emitLog();
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-      emitLog();
-    });
+    if (child.stdout) {
+      child.stdout.on("data", (chunk) => {
+        stdout += String(chunk);
+        emitLog();
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (chunk) => {
+        stderr += String(chunk);
+        emitLog();
+      });
+    }
     child.on("error", (error) => {
       signal.removeEventListener("abort", onAbort);
       reject(error);
     });
     child.on("close", (code) => {
       signal.removeEventListener("abort", onAbort);
-      const log = buildDeployLog(stdout, stderr);
+      const log2 = buildDeployLog(stdout, stderr);
       if (code === 0) {
-        resolve5({ log });
+        resolve5({ log: log2 });
         return;
       }
       const error = new Error(
         `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${code ?? "unknown"}: ${command}`
       );
-      error.log = log;
+      error.log = log2;
       reject(error);
     });
   });
 }
-function createDeployLogSyncer(api, deploymentRunId) {
-  let lastSyncedLog = "";
-  let latestLog = "";
-  const syncIfChanged = async () => {
-    if (!latestLog || latestLog === lastSyncedLog) {
-      return;
-    }
-    await api.cli.syncTaskDeploymentLog({
-      id: deploymentRunId,
-      log: latestLog
-    });
-    lastSyncedLog = latestLog;
-  };
-  const timer = setInterval(() => {
-    void syncIfChanged().catch((error) => {
-      console.error(
-        "[apm] deploy log sync failed:",
-        error instanceof Error ? error.message : String(error)
-      );
-    });
-  }, DEPLOY_LOG_SYNC_INTERVAL_MS);
-  return {
-    updateLog(log) {
-      latestLog = log;
-    },
-    async flush() {
-      clearInterval(timer);
-      await syncIfChanged();
-    },
-    dispose() {
-      clearInterval(timer);
-    }
-  };
-}
+
+// src/commands/connect/deploy-run.ts
 async function handleInboundDeploy(cfg, msg, signal) {
   const api = createApmApiClient(cfg);
   const deploymentRunId = msg.deploymentRunId;
@@ -1331,9 +1601,10 @@ async function handleInboundDeploy(cfg, msg, signal) {
     status: "DEPLOYING"
   });
   const workdir = requireRemoteWorkdir(msg.workdir);
-  const command = resolveDeployCommand(workdir, msg.environment);
+  const environment = msg.environment;
+  const command = resolveDeployCommand(workdir, environment);
   if (!command) {
-    const error = missingDeployCommandMessage(msg.environment);
+    const error = missingDeployCommandMessage(environment);
     console.error(`[apm] ${error}`);
     await api.cli.completeTaskDeployment({
       id: deploymentRunId,
@@ -1344,34 +1615,37 @@ async function handleInboundDeploy(cfg, msg, signal) {
     return;
   }
   console.log(
-    `[apm] deploy start id=${deploymentRunId} env=${msg.environment} cwd=${workdir}`
+    `[apm] deploy start id=${deploymentRunId} env=${environment} cwd=${workdir}`
   );
   console.log(`[apm] deploy command: ${command}`);
   const logSyncer = createDeployLogSyncer(api, deploymentRunId);
   let latestLog = "";
   try {
-    const { log } = await runShellCommand(command, workdir, signal, (log2) => {
-      latestLog = log2;
-      logSyncer.updateLog(log2);
+    const { log: log2 } = await runDeployShellCommand(command, workdir, {
+      signal,
+      onOutput: (log3) => {
+        latestLog = log3;
+        logSyncer.updateLog(log3);
+      }
     });
-    latestLog = log;
-    logSyncer.updateLog(log);
+    latestLog = log2;
+    logSyncer.updateLog(log2);
     await logSyncer.flush();
     await api.cli.completeTaskDeployment({
       id: deploymentRunId,
       status: "SUCCESS",
-      log
+      log: log2
     });
     console.log(`[apm] deploy success id=${deploymentRunId}`);
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
-    const log = error && typeof error === "object" && "log" in error ? String(error.log ?? latestLog) : latestLog;
-    logSyncer.updateLog(log);
+    const log2 = error && typeof error === "object" && "log" in error ? String(error.log ?? latestLog) : latestLog;
+    logSyncer.updateLog(log2);
     await logSyncer.flush();
     await api.cli.completeTaskDeployment({
       id: deploymentRunId,
       status: "FAILED",
-      log,
+      log: log2,
       error: detail
     });
     console.error(`[apm] deploy failed id=${deploymentRunId}: ${detail}`);
@@ -1381,10 +1655,10 @@ async function handleInboundDeploy(cfg, msg, signal) {
 }
 
 // src/commands/sync-task-documents.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync7 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
+import { join as join11 } from "path";
 function listLocalMarkdownFiles(docsDir) {
-  if (!existsSync6(docsDir)) {
+  if (!existsSync7(docsDir)) {
     return [];
   }
   return readdirSync4(docsDir).filter(
@@ -1399,8 +1673,8 @@ function remoteDocumentByLocalName(remoteDocuments, localFileName) {
   });
 }
 async function upsertLocalDocumentFile(api, taskId, docsDir, fileName) {
-  const content = readFileSync7(join10(docsDir, fileName), "utf8");
-  const name = documentPlatformName(join10(docsDir, fileName));
+  const content = readFileSync9(join11(docsDir, fileName), "utf8");
+  const name = documentPlatformName(join11(docsDir, fileName));
   return api.cli.upsertDocument({
     taskId,
     name,
@@ -1422,7 +1696,7 @@ async function syncTaskDocuments(cfg, taskId, workdir, options) {
   const remoteDocuments = options?.remoteDocuments ?? await api.cli.listDocuments({ taskId: trimmedTaskId });
   let synced = 0;
   for (const fileName of localFiles) {
-    const content = readFileSync7(join10(docsDir, fileName), "utf8");
+    const content = readFileSync9(join11(docsDir, fileName), "utf8");
     const remote = remoteDocumentByLocalName(remoteDocuments, fileName);
     if (remote && remote.content === content) {
       continue;
@@ -1450,8 +1724,8 @@ import {
 import { setMaxListeners as setMaxListeners2 } from "node:events";
 
 // src/commands/connect/plan-document.ts
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join11 } from "node:path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join12 } from "node:path";
 function normalizePlanContent(plan) {
   return plan.replace(/\\n/g, "\n").trim();
 }
@@ -1521,10 +1795,10 @@ function saveMemberPlanDocument(input) {
     input.workdir
   );
   mkdirSync5(toFsPath(docsDir), { recursive: true });
-  const filePath = join11(docsDir, fileName);
+  const filePath = join12(docsDir, fileName);
   const normalized = trimmedContent.endsWith("\n") ? trimmedContent : `${trimmedContent}
 `;
-  writeFileSync7(toFsPath(filePath), normalized, "utf8");
+  writeFileSync8(toFsPath(filePath), normalized, "utf8");
   console.log(`[apm] \u5DF2\u4FDD\u5B58\u8BA1\u5212\u6587\u6863: ${fileName}`);
   return fileName;
 }
@@ -1682,17 +1956,17 @@ function logAbortSignalStats(signal, label) {
 }
 
 // src/commands/connect/agent-task-registry.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
 import { dirname as dirname4, resolve as resolve3 } from "node:path";
 function registryPath(workdir, taskId) {
   return resolve3(workdir, ".apm", "tasks", taskId, "cursor-agents.json");
 }
-function readRegistry(path10) {
-  if (!existsSync7(path10)) {
+function readRegistry(path13) {
+  if (!existsSync8(path13)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path10, "utf8"));
+    const parsed = JSON.parse(readFileSync10(path13, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const result = {};
       for (const [key, value] of Object.entries(
@@ -1708,28 +1982,28 @@ function readRegistry(path10) {
   }
   return {};
 }
-function writeRegistry(path10, registry) {
-  mkdirSync6(dirname4(path10), { recursive: true });
-  writeFileSync8(path10, `${JSON.stringify(registry, null, 2)}
+function writeRegistry(path13, registry) {
+  mkdirSync6(dirname4(path13), { recursive: true });
+  writeFileSync9(path13, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function loadTaskAgentId(workdir, taskId, user) {
   return readRegistry(registryPath(workdir, taskId))[user];
 }
 function saveTaskAgentId(workdir, taskId, user, agentId) {
-  const path10 = registryPath(workdir, taskId);
-  const registry = readRegistry(path10);
+  const path13 = registryPath(workdir, taskId);
+  const registry = readRegistry(path13);
   registry[user] = agentId;
-  writeRegistry(path10, registry);
+  writeRegistry(path13, registry);
 }
 function clearTaskAgentId(workdir, taskId, user) {
-  const path10 = registryPath(workdir, taskId);
-  const registry = readRegistry(path10);
+  const path13 = registryPath(workdir, taskId);
+  const registry = readRegistry(path13);
   if (!(user in registry)) {
     return;
   }
   delete registry[user];
-  writeRegistry(path10, registry);
+  writeRegistry(path13, registry);
 }
 
 // src/commands/connect/cursor-log.ts
@@ -2042,14 +2316,13 @@ function createMailReplyDraft() {
 }
 
 // src/commands/connect/task-pull.ts
-import { writeFileSync as writeFileSync10 } from "fs";
-import { join as join13 } from "path";
+import { writeFileSync as writeFileSync11 } from "fs";
+import { join as join14 } from "path";
 import { stringify as yamlStringify } from "yaml";
 
 // src/rules-sync.ts
-import { basename as basename2, extname, join as join12 } from "path";
-import { existsSync as existsSync8, readFileSync as readFileSync9, rmSync as rmSync3, writeFileSync as writeFileSync9 } from "fs";
-var MANIFEST_FILE2 = ".rules-sync-manifest.json";
+import { basename as basename2, extname, join as join13 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync5, readFileSync as readFileSync11, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync10 } from "fs";
 function ruleLocalFileName(ruleName) {
   const trimmed = ruleName.trim();
   if (!trimmed) return "rule.md";
@@ -2057,46 +2330,31 @@ function ruleLocalFileName(ruleName) {
   if (extname(sanitized).toLowerCase() === ".md") return sanitized;
   return `${sanitized}.md`;
 }
-function loadManifest(rulesDir) {
-  const path10 = join12(rulesDir, MANIFEST_FILE2);
-  if (!existsSync8(toFsPath(path10))) {
-    return { version: 1, rules: {} };
-  }
-  try {
-    const parsed = JSON.parse(
-      readFileSync9(toFsPath(path10), "utf8")
-    );
-    if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
-      return parsed;
-    }
-  } catch {
-  }
-  return { version: 1, rules: {} };
-}
-function saveManifest(rulesDir, manifest) {
-  writeFileSync9(
-    toFsPath(join12(rulesDir, MANIFEST_FILE2)),
-    `${JSON.stringify(manifest, null, 2)}
-`,
-    "utf8"
-  );
-}
 function isBaseRuleFileName(fileName) {
   return listBaseRuleFileNames().includes(basename2(fileName));
 }
+function findRuleManifestEntry(manifest, rule, fileName) {
+  const manifestPath = toRuleManifestPath(fileName);
+  return (manifest?.documents ?? []).find(
+    (entry) => entry.remoteId === rule.id || entry.path === manifestPath
+  );
+}
 function isRuleUpToDate(entry, rule, dest) {
-  if (!entry || !existsSync8(toFsPath(dest))) return false;
-  if (entry.fileName !== ruleLocalFileName(rule.name)) return false;
+  if (!entry || !existsSync9(toFsPath(dest))) return false;
+  if (entry.path !== toRuleManifestPath(ruleLocalFileName(rule.name))) {
+    return false;
+  }
   const updatedAt = rule.updatedAt ?? "";
   if (entry.updatedAt !== updatedAt) return false;
-  const localContent = readFileSync9(toFsPath(dest), "utf8");
+  const localContent = readFileSync11(toFsPath(dest), "utf8");
   return localContent === (rule.content ?? "");
 }
 async function syncPlatformRules(cfg, workdirPath, apmRoot) {
   const api = createApmApiClient(cfg);
   const baseline = await api.cli.workspaceBaseline({ workdirPath });
   const repositoryId = baseline.repositoryId;
-  const rulesDir = join12(apmRoot ?? workspaceApmDir(workdirPath), "rules");
+  const targetApmRoot = apmRoot ?? workspaceApmDir(workdirPath);
+  const rulesDir = join13(targetApmRoot, "rules");
   await ensureDirExists(rulesDir);
   if (!repositoryId) {
     console.log(
@@ -2105,40 +2363,65 @@ async function syncPlatformRules(cfg, workdirPath, apmRoot) {
     return { written: [], skipped: [], removed: [], repositoryId: null };
   }
   const { list } = await api.cli.listRules({ repositoryId });
-  const manifest = loadManifest(rulesDir);
-  const nextManifest = { version: 1, rules: {} };
+  const manifest = readApmManifest(targetApmRoot);
   const remoteIds = /* @__PURE__ */ new Set();
   const written = [];
   const skipped = [];
+  const ruleEntries = [];
   for (const rule of list) {
     remoteIds.add(rule.id);
     const fileName = ruleLocalFileName(rule.name);
-    const dest = join12(rulesDir, fileName);
-    const entry = manifest.rules[rule.id];
+    const dest = join13(rulesDir, fileName);
+    const entry = findRuleManifestEntry(manifest, rule, fileName);
     const updatedAt = rule.updatedAt ?? "";
     if (isRuleUpToDate(entry, rule, dest)) {
-      nextManifest.rules[rule.id] = entry;
+      ruleEntries.push(entry);
       skipped.push(fileName);
       console.log(`[apm] \u89C4\u5219\u65E0\u53D8\u5316\uFF0C\u5DF2\u8DF3\u8FC7: rules/${fileName}`);
       continue;
     }
-    writeFileSync9(toFsPath(dest), rule.content ?? "", "utf8");
-    nextManifest.rules[rule.id] = { fileName, updatedAt };
+    writeFileSync10(toFsPath(dest), rule.content ?? "", "utf8");
+    ruleEntries.push(
+      buildManifestEntryFromFile({
+        path: toRuleManifestPath(fileName),
+        content: rule.content ?? "",
+        updatedAt,
+        remoteId: rule.id
+      })
+    );
     written.push(fileName);
     console.log(`[apm] \u5DF2\u540C\u6B65\u5E73\u53F0\u89C4\u5219: rules/${fileName}`);
   }
   const removed = [];
-  for (const [ruleId, entry] of Object.entries(manifest.rules)) {
-    if (remoteIds.has(ruleId)) continue;
-    if (isBaseRuleFileName(entry.fileName)) continue;
-    const dest = join12(rulesDir, entry.fileName);
-    if (existsSync8(toFsPath(dest))) {
+  for (const entry of manifest?.documents ?? []) {
+    if (!entry.path.startsWith("rules/")) continue;
+    if (!entry.remoteId || remoteIds.has(entry.remoteId)) continue;
+    const fileName = basename2(entry.path);
+    if (isBaseRuleFileName(fileName)) continue;
+    const dest = join13(rulesDir, fileName);
+    if (existsSync9(toFsPath(dest))) {
       rmSync3(toFsPath(dest), { force: true });
     }
-    removed.push(entry.fileName);
-    console.log(`[apm] \u5DF2\u79FB\u9664\u5DF2\u4E0B\u7EBF\u7684\u5E73\u53F0\u89C4\u5219: rules/${entry.fileName}`);
+    removed.push(fileName);
+    console.log(`[apm] \u5DF2\u79FB\u9664\u5DF2\u4E0B\u7EBF\u7684\u5E73\u53F0\u89C4\u5219: rules/${fileName}`);
+  }
+  const coveredPaths = new Set(ruleEntries.map((entry) => entry.path));
+  for (const fileName of readdirSync5(rulesDir)) {
+    const dest = join13(rulesDir, fileName);
+    if (!statSync4(dest).isFile()) continue;
+    const manifestPath = toRuleManifestPath(fileName);
+    if (coveredPaths.has(manifestPath)) continue;
+    ruleEntries.push(
+      buildManifestEntryFromFile({
+        path: manifestPath,
+        content: readFileSync11(toFsPath(dest), "utf8")
+      })
+    );
   }
-  saveManifest(rulesDir, nextManifest);
+  writeApmManifest(
+    targetApmRoot,
+    mergeManifestSection(manifest, "rules", ruleEntries, repositoryId)
+  );
   return { written, skipped, removed, repositoryId };
 }
 
@@ -2150,15 +2433,14 @@ async function runTaskPull(cfg, detail) {
   const dir = taskDir(taskId, apmRoot, workdir);
   const docsDir = taskDocsDir(taskId, apmRoot, workdir);
   await ensureDirExists(docsDir);
-  writeFileSync10(taskRulePath(taskId, apmRoot, workdir), "", "utf8");
-  writeFileSync10(
+  writeFileSync11(
     taskTaskPath(taskId, apmRoot, workdir),
     detail.task.description ?? "",
     "utf8"
   );
   for (const doc of detail.documents) {
     const fileName = documentLocalFileName(doc.name);
-    writeFileSync10(join13(docsDir, fileName), doc.content ?? "", "utf8");
+    writeFileSync11(join14(docsDir, fileName), doc.content ?? "", "utf8");
   }
   const members = detail.studio?.members ?? [];
   const taskYaml = yamlStringify(
@@ -2176,7 +2458,7 @@ async function runTaskPull(cfg, detail) {
     },
     { lineWidth: 0 }
   );
-  writeFileSync10(
+  writeFileSync11(
     taskYamlPath(taskId, apmRoot, workdir),
     taskYaml.endsWith("\n") ? taskYaml : `${taskYaml}
 `,
@@ -2420,7 +2702,7 @@ function reexecConnect(options) {
   if (server) {
     args.push("--server", server);
   }
-  const result = spawnSync2(process.execPath, args, { stdio: "inherit" });
+  const result = spawnSync3(process.execPath, args, { stdio: "inherit" });
   if (result.error) {
     console.error("[apm] \u91CD\u542F connect \u5931\u8D25:", result.error.message);
     process.exit(1);
@@ -2548,19 +2830,19 @@ async function runConnect(options) {
 import path5 from "node:path";
 
 // src/commands/deploy/internal/apm-config.ts
-import { existsSync as existsSync9, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync12 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 function loadApmConfig(options) {
   const p = resolve4(
     process.cwd(),
     options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
   );
-  if (!existsSync9(p)) {
+  if (!existsSync10(p)) {
     console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
     process.exit(1);
   }
   try {
-    const raw = readFileSync10(p, "utf8");
+    const raw = readFileSync12(p, "utf8");
     return JSON.parse(raw);
   } catch (e) {
     console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
@@ -2674,6 +2956,60 @@ function resolveWisdomDeployFromApmConfig(cfg) {
     remotePath: reqWd(w.remotePath, "remotePath").trim()
   };
 }
+function reqHc(v, field) {
+  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
+    console.error(`apm.config.json \u4E2D healthCheck.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    process.exit(1);
+  }
+  return v;
+}
+function reqHealthPositiveInt(v, field) {
+  const n = Number(v);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
+    console.error(`apm.config.json \u4E2D healthCheck.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
+    process.exit(1);
+  }
+  return n;
+}
+function resolveHealthCheckFromApmConfig(cfg) {
+  const h = cfg.healthCheck ?? {};
+  return {
+    port: reqHealthPositiveInt(h.port, "port"),
+    context: reqHc(h.context, "context").trim(),
+    timeout: reqHealthPositiveInt(h.timeout, "timeout")
+  };
+}
+function resolveWisdomJarDeployFromApmConfig(cfg) {
+  const base = resolveWisdomDeployFromApmConfig(cfg);
+  const w = cfg.wisdomDeploy ?? {};
+  const jarPath = reqWd(w.jarPath, "jarPath").trim().replace(/\\/g, "/");
+  const remoteAppDir = posixDirname(jarPath);
+  const projectName = reqTopLevelName(cfg);
+  return {
+    ...base,
+    projectName,
+    jarPath,
+    mavenLocalRepo: reqWd(w.mavenLocalRepo, "mavenLocalRepo").trim(),
+    remoteAppDir,
+    remoteLibDir: `${remoteAppDir}/lib`,
+    startupJar: posixBasename(jarPath),
+    packageName: `${projectName}.jar.zip`,
+    healthCheck: resolveHealthCheckFromApmConfig(cfg)
+  };
+}
+function posixDirname(p) {
+  const normalized = p.replace(/\\/g, "/");
+  const idx = normalized.lastIndexOf("/");
+  if (idx <= 0) {
+    return normalized.startsWith("/") ? "/" : ".";
+  }
+  return normalized.slice(0, idx);
+}
+function posixBasename(p) {
+  const normalized = p.replace(/\\/g, "/");
+  const idx = normalized.lastIndexOf("/");
+  return idx >= 0 ? normalized.slice(idx + 1) : normalized;
+}
 
 // src/commands/deploy/internal/backend-deploy/backend-deploy-workflow.ts
 import path4 from "node:path";
@@ -2682,7 +3018,7 @@ import path4 from "node:path";
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
-import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
 import path from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
@@ -2694,8 +3030,8 @@ function asOptionalTlsBuffer(value) {
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync10(normalized)) {
-    return readFileSync11(normalized);
+  if (existsSync11(normalized)) {
+    return readFileSync13(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -2905,7 +3241,7 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync11, readFileSync as readFileSync12, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync14, statSync as statSync5 } from "node:fs";
 import path2 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
@@ -2922,10 +3258,10 @@ function loadEnvFromFile(envFilePath) {
     return {};
   }
   const targetPath = path2.resolve(envFilePath);
-  if (!existsSync11(targetPath) || !statSync4(targetPath).isFile()) {
+  if (!existsSync12(targetPath) || !statSync5(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync12(targetPath, "utf-8");
+  const raw = readFileSync14(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -2990,7 +3326,7 @@ function assertDeployImageTag(tag) {
 }
 
 // src/commands/deploy/internal/backend-deploy/local-docker-build.ts
-import { platform as platform2 } from "node:os";
+import { platform as platform3 } from "node:os";
 
 // src/commands/deploy/internal/backend-deploy/command-runner.ts
 import { execSync } from "child_process";
@@ -3050,7 +3386,7 @@ var CommandRunner = class {
 
 // src/commands/deploy/internal/backend-deploy/local-docker-build.ts
 function dockerBuildPlatformFlags() {
-  return platform2() === "darwin" ? ["--platform", "linux/amd64"] : [];
+  return platform3() === "darwin" ? ["--platform", "linux/amd64"] : [];
 }
 function buildDockerImageLocally(params, cwd) {
   const platformFlags = dockerBuildPlatformFlags();
@@ -3096,12 +3432,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import path3 from "node:path";
 function resolveDockerBuildPaths(cwd) {
   const dockerfilePath = path3.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
-  if (!existsSync12(dockerfilePath)) {
+  if (!existsSync13(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");
@@ -3230,14 +3566,14 @@ import { copyFile, readdir as readdir2, stat } from "node:fs/promises";
 import path7 from "node:path";
 
 // src/commands/deploy/internal/minio.ts
-import { statSync as statSync5 } from "node:fs";
+import { statSync as statSync6 } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import path6 from "node:path";
 import * as Minio from "minio";
 var DEFAULT_MAX_FILE_SIZE_MB = 50;
 async function isDirectoryPath(dir) {
   try {
-    const st = statSync5(dir);
+    const st = statSync6(dir);
     return st.isDirectory();
   } catch {
     return false;
@@ -3267,7 +3603,7 @@ async function collectFiles(root) {
       if (e.isDirectory()) {
         await walk(abs, rel);
       } else if (e.isFile()) {
-        const st = statSync5(abs);
+        const st = statSync6(abs);
         out.push({
           absPath: abs,
           relativePath: rel.replace(/\\/g, "/"),
@@ -3525,18 +3861,47 @@ function registerDeployFrontendCommands(program) {
   );
 }
 
+// src/commands/deploy/run.ts
+import path8 from "node:path";
+function registerDeployRunCommands(program) {
+  program.command("deploy").description(
+    "\u8BFB\u53D6 apm.config.json \u4E2D deploy.<env> \u5E76\u4EE5 shell \u6267\u884C\uFF08\u73AF\u5883\uFF1Atest | online\uFF09"
+  ).argument("<env>", "\u90E8\u7F72\u73AF\u5883\uFF1Atest \u6216 online").option("--cwd <path>", "\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09").action(async (env, opts) => {
+    if (!isDeployEnvironment(env)) {
+      console.error(`\u65E0\u6548\u90E8\u7F72\u73AF\u5883 "${env}"\uFF0C\u4EC5\u652F\u6301 test \u6216 online`);
+      process.exit(1);
+    }
+    const workdir = path8.resolve(opts.cwd ?? process.cwd());
+    const command = resolveDeployCommand(workdir, env);
+    if (!command) {
+      console.error(missingDeployCommandMessage(env));
+      process.exit(1);
+    }
+    console.log(`[apm] deploy env=${env} cwd=${workdir}`);
+    console.log(`[apm] deploy command: ${command}`);
+    try {
+      await runDeployShellCommand(command, workdir, { inheritStdio: true });
+      console.log(`[apm] deploy success env=${env}`);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      console.error(`[apm] deploy failed env=${env}: ${detail}`);
+      process.exit(1);
+    }
+  });
+}
+
 // src/commands/deploy/sftp.ts
-import path9 from "node:path";
+import path10 from "node:path";
 
 // src/commands/deploy/internal/wisdom-sftp.ts
 import { readdir as readdir3, readFile as readFile2, unlink, writeFile } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 import JSZip from "jszip";
 import SftpClient from "ssh2-sftp-client";
 async function addDirToZip(dir, zipFolder) {
   const entries = await readdir3(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path8.join(dir, entry.name);
+    const fullPath = path9.join(dir, entry.name);
     if (entry.isDirectory()) {
       const folder = zipFolder.folder(entry.name);
       if (folder) {
@@ -3651,8 +4016,8 @@ async function uploadAndMaybeExtract(settings, localZip, extract) {
   }
 }
 async function runWisdomSftpDeploy(params) {
-  const zipPath = path8.join(params.localDir, "..", ".deploy-sftp-dist.zip");
-  const resolvedZipPath = path8.resolve(zipPath);
+  const zipPath = path9.join(params.localDir, "..", ".deploy-sftp-dist.zip");
+  const resolvedZipPath = path9.resolve(zipPath);
   let zipSizeBytes = 0;
   try {
     zipSizeBytes = await zipDirectory(params.localDir, resolvedZipPath);
@@ -3693,7 +4058,7 @@ function registerDeploySftpCommands(program) {
     async (opts) => {
       const cfg = loadApmConfig({ configPath: opts.config });
       const settings = resolveWisdomDeployFromApmConfig(cfg);
-      const root = path9.resolve(process.cwd(), opts.dir || "apps/web/dist");
+      const root = path10.resolve(process.cwd(), opts.dir || "apps/web/dist");
       if (!await isDirectoryPath(root)) {
         console.error(`\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${root}`);
         process.exit(1);
@@ -3714,11 +4079,501 @@ function registerDeploySftpCommands(program) {
   );
 }
 
+// src/commands/deploy/wisdom-jar.ts
+import path12 from "node:path";
+
+// src/commands/deploy/internal/wisdom-jar-deploy.ts
+import {
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync15,
+  readdirSync as readdirSync6,
+  statSync as statSync7,
+  writeFileSync as writeFileSync12
+} from "node:fs";
+import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import path11 from "node:path";
+import JSZip2 from "jszip";
+import SftpClient2 from "ssh2-sftp-client";
+var DEFAULT_MAVEN_MODULE = "jeecg-module-system/jeecg-system-start";
+var DEFAULT_MAVEN_PROFILE = "dev";
+var SPRINGBOOT_SCRIPT = "springboot.sh";
+function log(message) {
+  const now = /* @__PURE__ */ new Date();
+  const hh = String(now.getHours()).padStart(2, "0");
+  const mm = String(now.getMinutes()).padStart(2, "0");
+  const ss = String(now.getSeconds()).padStart(2, "0");
+  console.log(`[${hh}:${mm}:${ss}] ${message}`);
+}
+function fail(message) {
+  log(`ERROR: ${message}`);
+  process.exit(1);
+}
+function shellSingleQuote2(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function expandPath(pathStr) {
+  return path11.resolve(expandUserHomePath(pathStr));
+}
+function relativeKey(projectRoot, filePath) {
+  return path11.relative(projectRoot, path11.resolve(filePath)).split(path11.sep).join("/");
+}
+function fileSignature(filePath) {
+  const stat2 = statSync7(filePath);
+  return { size: stat2.size, mtime: stat2.mtimeMs };
+}
+function loadManifest(manifestFile) {
+  if (!existsSync14(manifestFile)) {
+    return {};
+  }
+  return JSON.parse(readFileSync15(manifestFile, "utf8"));
+}
+function saveManifest(manifestFile, manifest) {
+  const dir = path11.dirname(manifestFile);
+  mkdirSync7(dir, { recursive: true });
+  writeFileSync12(manifestFile, JSON.stringify(manifest, null, 2), "utf8");
+}
+function isProjectLibJar(jarName) {
+  return jarName.startsWith("jeecg-");
+}
+function shouldUploadLibFile(projectRoot, localPath, remoteSize, manifest) {
+  if (remoteSize === void 0) {
+    return { shouldUpload: false, reason: "\u8FDC\u7A0B\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7" };
+  }
+  const localSize = statSync7(localPath).size;
+  if (localSize !== remoteSize) {
+    return {
+      shouldUpload: true,
+      reason: `\u5927\u5C0F\u53D8\u5316 ${remoteSize} -> ${localSize}`
+    };
+  }
+  const jarName = path11.basename(localPath);
+  if (isProjectLibJar(jarName) && manifest) {
+    const key = relativeKey(projectRoot, localPath);
+    const current = fileSignature(localPath);
+    const previous = manifest[key];
+    if (!previous) {
+      return { shouldUpload: true, reason: "\u9879\u76EE\u6A21\u5757\u672A\u8BB0\u5F55" };
+    }
+    if (previous.size !== current.size) {
+      return { shouldUpload: true, reason: "\u9879\u76EE\u6A21\u5757\u5927\u5C0F\u53D8\u5316" };
+    }
+    if (previous.mtime < current.mtime) {
+      return { shouldUpload: true, reason: "\u9879\u76EE\u6A21\u5757\u91CD\u65B0\u6784\u5EFA" };
+    }
+  }
+  return { shouldUpload: false, reason: "\u5927\u5C0F\u4E00\u81F4\uFF0C\u8DF3\u8FC7" };
+}
+function listLibFilesToUpload(projectRoot, localLibDir, remoteStats, manifest) {
+  const entries = [];
+  const jarFiles = readdirSync6(localLibDir).filter((name) => name.endsWith(".jar")).sort();
+  for (const jarName of jarFiles) {
+    const jarPath = path11.join(localLibDir, jarName);
+    const { shouldUpload, reason } = shouldUploadLibFile(
+      projectRoot,
+      jarPath,
+      remoteStats.get(jarName),
+      manifest
+    );
+    if (shouldUpload) {
+      entries.push({ path: jarPath, arcname: jarName, reason });
+    }
+  }
+  return entries;
+}
+async function createUpdatePackage(entries, packageName, cacheDir) {
+  mkdirSync7(cacheDir, { recursive: true });
+  const zipPath = path11.join(cacheDir, packageName);
+  log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${packageName}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
+  const zip = new JSZip2();
+  for (const entry of entries) {
+    const content = await readFile3(entry.path);
+    zip.file(entry.arcname, content);
+    log(`  \u6253\u5305: ${entry.arcname} (${entry.reason})`);
+  }
+  const buffer = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 }
+  });
+  await writeFile2(zipPath, buffer);
+  return zipPath;
+}
+function getMvnExecutable() {
+  const candidates = process.platform === "win32" ? ["mvn.cmd", "mvn.bat", "mvn"] : ["mvn"];
+  for (const name of candidates) {
+    const result = spawnSyncShellCommand(`${name} --version`, {
+      encoding: "utf8"
+    });
+    if (result.status === 0) {
+      return name;
+    }
+  }
+  fail("\u672A\u627E\u5230 mvn \u547D\u4EE4\uFF0C\u8BF7\u786E\u8BA4 Maven \u5DF2\u5B89\u88C5\u5E76\u52A0\u5165 PATH");
+  return "mvn";
+}
+function runMavenBuild(projectRoot, mavenRepo, profile) {
+  const mvn = getMvnExecutable();
+  const repoArg = quoteShellArg(normalizeMavenLocalRepoPath(mavenRepo));
+  const command = `${mvn} clean package -P${profile} -Dmaven.repo.local=${repoArg} -DskipTests`;
+  log(`\u5F00\u59CB Maven \u6784\u5EFA: ${command}`);
+  log(`Maven \u672C\u5730\u4ED3\u5E93: ${mavenRepo}`);
+  const result = spawnSyncShellCommand(command, {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    fail(`Maven \u6784\u5EFA\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${result.status ?? "unknown"}`);
+  }
+}
+function locateLibDir(projectRoot, mavenModule) {
+  const targetDir = path11.join(projectRoot, mavenModule, "target");
+  if (!existsSync14(targetDir)) {
+    fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
+  }
+  const libDir = path11.join(targetDir, "lib");
+  if (!existsSync14(libDir) || !statSync7(libDir).isDirectory()) {
+    fail(`lib \u76EE\u5F55\u4E0D\u5B58\u5728: ${libDir}`);
+  }
+  const libJars = readdirSync6(libDir).filter((name) => name.endsWith(".jar"));
+  if (libJars.length === 0) {
+    fail(`lib \u76EE\u5F55\u4E0B\u6CA1\u6709\u4F9D\u8D56 JAR: ${libDir}`);
+  }
+  log(`\u5B9A\u4F4D lib \u4EA7\u7269: ${libJars.length} \u4E2A`);
+  return libDir;
+}
+async function getRemoteFileStats(sftp, remoteDir) {
+  const stats = /* @__PURE__ */ new Map();
+  try {
+    const list = await sftp.list(remoteDir);
+    for (const item of list) {
+      if (item.name.endsWith(".jar")) {
+        stats.set(item.name, item.size);
+      }
+    }
+  } catch {
+  }
+  return stats;
+}
+async function uploadUpdatePackage(sftp, zipPath, settings) {
+  const remoteDir = settings.remotePath.replace(/\/$/, "");
+  const remotePath = `${remoteDir}/${path11.basename(zipPath)}`;
+  log(`\u4E0A\u4F20\u66F4\u65B0\u5305 -> ${remotePath}`);
+  try {
+    await sftp.put(zipPath, remotePath);
+    log("\u66F4\u65B0\u5305\u4E0A\u4F20\u6210\u529F");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    fail(`\u66F4\u65B0\u5305\u4E0A\u4F20\u5931\u8D25: ${message}`);
+  }
+  return remotePath;
+}
+function updateManifestEntries(projectRoot, manifest, entries) {
+  for (const entry of entries) {
+    manifest[relativeKey(projectRoot, entry.path)] = fileSignature(entry.path);
+  }
+  return manifest;
+}
+function runRemoteCommand(client, command, options = {}) {
+  const { check = true, stream = false, getPty = false } = options;
+  log(`\u8FDC\u7A0B\u6267\u884C: ${command}`);
+  return new Promise((resolve5, reject) => {
+    client.exec(command, { pty: getPty }, (err, execStream) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      let stdout = "";
+      let stderr = "";
+      execStream.on("data", (data) => {
+        const text = data.toString("utf8");
+        stdout += text;
+        if (stream) {
+          process.stdout.write(text);
+        }
+      });
+      execStream.stderr.on("data", (data) => {
+        const text = data.toString("utf8");
+        stderr += text;
+        if (stream) {
+          process.stdout.write(text);
+        }
+      });
+      execStream.on("close", (code) => {
+        const exitCode = code ?? 0;
+        const out = stdout.trim();
+        const errText = getPty ? "" : stderr.trim();
+        if (!stream) {
+          if (out) {
+            console.log(out);
+          }
+          if (errText) {
+            console.error(errText);
+          }
+        } else if (stdout && !stdout.endsWith("\n")) {
+          console.log();
+        }
+        if (check && exitCode !== 0) {
+          fail(`\u8FDC\u7A0B\u547D\u4EE4\u5931\u8D25 (exit ${exitCode}): ${command}`);
+        }
+        resolve5({ exitCode, stdout: out, stderr: errText });
+      });
+    });
+  });
+}
+async function extractUpdatePackageOnRemote(client, settings, remoteZipPath) {
+  const remoteLibDir = settings.remoteLibDir;
+  const quotedZip = shellSingleQuote2(remoteZipPath);
+  const quotedLib = shellSingleQuote2(remoteLibDir);
+  const script = `
+set -e
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+unzip -oq ${quotedZip} -d "$TMP"
+updated=0
+while IFS= read -r -d '' src; do
+  name=$(basename "$src")
+  dest=${quotedLib}/"$name"
+  if [ -f "$dest" ]; then
+    cp -f "$src" "$dest"
+    echo "\u8986\u76D6: $name"
+    updated=$((updated + 1))
+  else
+    echo "\u8DF3\u8FC7(\u8FDC\u7A0B\u4E0D\u5B58\u5728): $name"
+  fi
+done < <(find "$TMP" -name '*.jar' -type f -print0)
+echo "UPDATED_COUNT=$updated"
+`;
+  const { stdout } = await runRemoteCommand(client, script);
+  const match = stdout.match(/UPDATED_COUNT=(\d+)/);
+  if (!match || match[1] === void 0) {
+    fail(`\u8FDC\u7A0B\u89E3\u538B\u5931\u8D25\uFF0C\u672A\u83B7\u53D6\u66F4\u65B0\u6570\u91CF
+\u8F93\u51FA: ${stdout || "(\u7A7A)"}`);
+    return 0;
+  }
+  const updated = Number.parseInt(match[1], 10);
+  log(`lib \u89E3\u538B\u5B8C\u6210: \u8986\u76D6 ${updated} \u4E2A`);
+  return updated;
+}
+function springbootOutputIndicatesSuccess(action, combined) {
+  const lower = combined.toLowerCase();
+  if (action === "health") {
+    return combined.includes("\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7");
+  }
+  if (action === "start" || action === "restart") {
+    return combined.includes("is starting") || lower.includes("is running");
+  }
+  if (action === "stop") {
+    return combined.includes("is stopping") || lower.includes("not running") || lower.includes("please check it");
+  }
+  if (action === "status") {
+    return lower.includes("running") || lower.includes("not running");
+  }
+  return true;
+}
+async function runSpringbootAction(client, settings, action, args = []) {
+  if (action === "start" || action === "restart") {
+    if (args.length === 0) {
+      fail(`\u8FDC\u7A0B ${action} \u7F3A\u5C11 jar \u53C2\u6570`);
+    }
+    const jar = args[0].trim().split(/\r?\n/)[0]?.trim() ?? "";
+    if (!jar) {
+      fail(`\u65E0\u6548\u7684 jar \u540D\u79F0: ${JSON.stringify(args[0])}`);
+    }
+  }
+  const quotedAppDir = shellSingleQuote2(settings.remoteAppDir);
+  const scriptArgs = [action, ...args].map(shellSingleQuote2).join(" ");
+  const command = `cd ${quotedAppDir} && ./${SPRINGBOOT_SCRIPT} ${scriptArgs}`;
+  const { exitCode, stdout, stderr } = await runRemoteCommand(client, command, {
+    check: false
+  });
+  const combined = `${stdout}
+${stderr}`.trim();
+  const outputOk = springbootOutputIndicatesSuccess(action, combined);
+  if (action === "health") {
+    if (exitCode !== 0 || !outputOk) {
+      fail(`\u5065\u5EB7\u68C0\u67E5\u5931\u8D25
+\u547D\u4EE4: ${command}
+\u8F93\u51FA: ${combined || "(\u7A7A)"}`);
+    }
+    return combined;
+  }
+  if (exitCode !== 0 && !outputOk) {
+    fail(`\u8FDC\u7A0B ${action} \u5931\u8D25: ${args.join(" ")}
+${combined}`);
+  }
+  if ((action === "start" || action === "restart") && !outputOk) {
+    fail(
+      `\u8FDC\u7A0B ${action} \u672A\u6210\u529F: ${args.join(" ")}
+\u547D\u4EE4: ${command}
+\u8F93\u51FA: ${combined || "(\u7A7A)"}`
+    );
+  }
+  return combined;
+}
+async function getRunningJar(client, settings) {
+  const combined = await runSpringbootAction(client, settings, "status", [
+    settings.startupJar
+  ]);
+  const text = combined.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").trim().toLowerCase();
+  if (text.includes("not running")) {
+    return null;
+  }
+  if (text.includes("running")) {
+    return settings.startupJar;
+  }
+  return null;
+}
+async function healthCheckService(client, settings) {
+  const port = String(settings.healthCheck.port);
+  const context = settings.healthCheck.context.trim();
+  const timeout = String(settings.healthCheck.timeout);
+  log(`\u5065\u5EB7\u68C0\u67E5: springboot.sh health ${port} ${context} ${timeout}`);
+  await runSpringbootAction(client, settings, "health", [
+    port,
+    context,
+    timeout
+  ]);
+}
+async function runWisdomJarDeploy(params) {
+  const {
+    projectRoot,
+    deployCacheDir,
+    configPath,
+    settings,
+    mavenModule = DEFAULT_MAVEN_MODULE,
+    mavenProfile = DEFAULT_MAVEN_PROFILE,
+    skipBuild = false
+  } = params;
+  const manifestFile = path11.join(deployCacheDir, "manifest.json");
+  const mavenRepo = expandPath(settings.mavenLocalRepo);
+  log(`=== \u81EA\u52A8\u90E8\u7F72: ${settings.projectName} ===`);
+  log(`\u914D\u7F6E\u6587\u4EF6: ${configPath}`);
+  log(`\u9879\u76EE\u6839\u76EE\u5F55: ${projectRoot}`);
+  if (!skipBuild) {
+    runMavenBuild(projectRoot, mavenRepo, mavenProfile);
+  } else {
+    log("\u8DF3\u8FC7 Maven \u6784\u5EFA\uFF08--skip-build\uFF09");
+  }
+  const libDir = locateLibDir(projectRoot, mavenModule);
+  const manifest = loadManifest(manifestFile);
+  const sftp = new SftpClient2();
+  log(`\u8FDE\u63A5\u670D\u52A1\u5668 ${settings.username}@${settings.host}:${settings.port}`);
+  try {
+    await sftp.connect({
+      host: settings.host,
+      port: settings.port,
+      username: settings.username,
+      password: settings.password,
+      readyTimeout: 3e4,
+      tryKeyboard: true
+    });
+    const client = sftp.client;
+    let needRestart = false;
+    let libUploadEntries = [];
+    const remoteLibStats = await getRemoteFileStats(
+      sftp,
+      settings.remoteLibDir
+    );
+    log("\u6536\u96C6 JAR \u66F4\u65B0...");
+    libUploadEntries = listLibFilesToUpload(
+      projectRoot,
+      libDir,
+      remoteLibStats,
+      manifest
+    );
+    let updated = 0;
+    if (libUploadEntries.length > 0) {
+      const zipPath = await createUpdatePackage(
+        libUploadEntries,
+        settings.packageName,
+        deployCacheDir
+      );
+      const remoteZipPath = await uploadUpdatePackage(sftp, zipPath, settings);
+      log("\u8FDC\u7A0B\u89E3\u538B lib \u76EE\u5F55\uFF08\u4EC5\u8986\u76D6\u5DF2\u6709 JAR\uFF09...");
+      updated = await extractUpdatePackageOnRemote(
+        client,
+        settings,
+        remoteZipPath
+      );
+    } else {
+      log("\u65E0 JAR \u9700\u8981\u66F4\u65B0\uFF0C\u8DF3\u8FC7\u66F4\u65B0\u5305\u4E0A\u4F20");
+    }
+    const runningJar = await getRunningJar(client, settings);
+    needRestart = updated > 0;
+    if (!needRestart && !runningJar) {
+      log("\u670D\u52A1\u672A\u8FD0\u884C\uFF0C\u9700\u8981\u542F\u52A8");
+      needRestart = true;
+    } else if (!needRestart) {
+      log("\u6CA1\u6709\u6587\u4EF6\u9700\u8981\u66F4\u65B0\uFF0C\u8DF3\u8FC7\u91CD\u542F");
+    }
+    if (needRestart) {
+      log("\u91CD\u542F\u670D\u52A1...");
+      await runSpringbootAction(client, settings, "restart", [
+        settings.startupJar
+      ]);
+    }
+    await healthCheckService(client, settings);
+    if (libUploadEntries.length > 0) {
+      saveManifest(
+        manifestFile,
+        updateManifestEntries(projectRoot, manifest, libUploadEntries)
+      );
+    }
+  } finally {
+    await sftp.end();
+  }
+  log("\u90E8\u7F72\u5B8C\u6210");
+}
+
+// src/commands/deploy/wisdom-jar.ts
+function registerDeployWisdomJarCommands(program) {
+  program.command("deploy-wisdom-jar").description(
+    "Maven \u6784\u5EFA Spring Boot \u9879\u76EE\uFF0C\u589E\u91CF\u4E0A\u4F20 lib JAR \u5E76\u901A\u8FC7 springboot.sh \u91CD\u542F\uFF08\u914D\u7F6E\u89C1 apm.config.json wisdomDeploy / healthCheck\uFF09"
+  ).option(
+    "--config <path>",
+    "apm.config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 .apm/apm.config.json\uFF09"
+  ).option(
+    "--module <path>",
+    "Maven \u6A21\u5757\u76F8\u5BF9\u8DEF\u5F84\uFF08\u9ED8\u8BA4 jeecg-module-system/jeecg-system-start\uFF09",
+    "jeecg-module-system/jeecg-system-start"
+  ).option("--profile <name>", "Maven profile\uFF08\u9ED8\u8BA4 dev\uFF09", "dev").option("--skip-build", "\u8DF3\u8FC7 Maven \u6784\u5EFA\uFF0C\u4EC5\u4E0A\u4F20\u4E0E\u91CD\u542F").action(
+    async (opts) => {
+      const cfg = loadApmConfig({ configPath: opts.config });
+      const settings = resolveWisdomJarDeployFromApmConfig(cfg);
+      const projectRoot = process.cwd();
+      const apmDir = workspaceApmDir(projectRoot);
+      const deployCacheDir = path12.join(apmDir, "deploy", ".deploy_cache");
+      const configPath = path12.resolve(
+        projectRoot,
+        opts.config ?? path12.join(apmDir, "apm.config.json")
+      );
+      try {
+        await runWisdomJarDeploy({
+          projectRoot,
+          deployCacheDir,
+          configPath,
+          settings,
+          mavenModule: opts.module,
+          mavenProfile: opts.profile,
+          skipBuild: Boolean(opts.skipBuild)
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error("\u90E8\u7F72\u5931\u8D25:", message);
+        process.exit(1);
+      }
+    }
+  );
+}
+
 // src/commands/deploy/index.ts
 function registerDeployCommands(program) {
+  registerDeployRunCommands(program);
   registerDeployBackendCommands(program);
   registerDeployFrontendCommands(program);
   registerDeploySftpCommands(program);
+  registerDeployWisdomJarCommands(program);
 }
 
 // src/index.ts