ai-project-manage-cli 6.0.64 → 6.0.66

package/dist/index.js

@@ -110,8 +110,8 @@ function toFsPath(inputPath) {
   }
   return `\\\\?\\${normalized}`;
 }
-function normalizeWorkdirPath(path10) {
-  let normalized = path10.trim().replace(/\\/g, "/").normalize("NFC");
+function normalizeWorkdirPath(path12) {
+  let normalized = path12.trim().replace(/\\/g, "/").normalize("NFC");
   if (normalized.startsWith("//?/")) {
     normalized = normalized.slice(4);
   }
@@ -326,9 +326,9 @@ function assertTemplateCopiedToApm(apmDir, workdir) {
     "sessions"
   ];
   for (const item of required) {
-    const path10 = join2(apmDir, item);
-    if (!existsSync(toFsPath(path10))) {
-      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path10}`);
+    const path12 = join2(apmDir, item);
+    if (!existsSync(toFsPath(path12))) {
+      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path12}`);
     }
   }
   const leakedRules = join2(workdir, "rules");
@@ -473,33 +473,19 @@ var requestConfig = {
       method: "DELETE",
       path: "/cli/repository-project-documents"
     }),
-    updateCoordinatorDeploymentStatus: defineEndpoint({
+    updateTaskDeploymentStatus: defineEndpoint({
       method: "PUT",
-      path: "/cli/coordinator-deployments/status"
+      path: "/cli/task-deployments/status"
     }),
-    syncCoordinatorDeploymentLog: defineEndpoint({
-      method: "PUT",
-      path: "/cli/coordinator-deployments/log"
-    }),
-    completeCoordinatorDeployment: defineEndpoint({
-      method: "PUT",
-      path: "/cli/coordinator-deployments/complete"
-    }),
-    updateCoordinatorDispatchStatus: defineEndpoint({
-      method: "PUT",
-      path: "/cli/coordinator-dispatches/status"
-    }),
-    appendCoordinatorDispatchResponse: defineEndpoint({
-      method: "PUT",
-      path: "/cli/coordinator-dispatches/append-response"
-    }),
-    completeCoordinatorDispatch: defineEndpoint({
+    syncTaskDeploymentLog: defineEndpoint(
+      {
+        method: "PUT",
+        path: "/cli/task-deployments/log"
+      }
+    ),
+    completeTaskDeployment: defineEndpoint({
       method: "PUT",
-      path: "/cli/coordinator-dispatches/complete"
-    }),
-    createCoordinatorDispatchQuestions: defineEndpoint({
-      method: "POST",
-      path: "/cli/coordinator-dispatches/questions"
+      path: "/cli/task-deployments/complete"
     })
   }
 };
@@ -627,14 +613,14 @@ function projectDocumentLocalPath(apmRoot, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
   return join4(projectDocumentsDir(apmRoot), ...normalized.split("/"));
 }
-function normalizeLocalDocumentPath(path10) {
-  const trimmed = path10.trim().replace(/\\/g, "/");
+function normalizeLocalDocumentPath(path12) {
+  const trimmed = path12.trim().replace(/\\/g, "/");
   if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path10}`);
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path12}`);
   }
   const segments = trimmed.split("/").filter(Boolean);
   if (segments.some((segment) => segment === ".." || segment === ".")) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path10}`);
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path12}`);
   }
   return segments.join("/");
 }
@@ -685,15 +671,15 @@ function diffManifestPaths(remote, local) {
     (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
   );
   const download = [];
-  for (const [path10, hash] of remoteMap) {
-    if (localMap.get(path10) !== hash) {
-      download.push(path10);
+  for (const [path12, hash] of remoteMap) {
+    if (localMap.get(path12) !== hash) {
+      download.push(path12);
     }
   }
   const deleteLocal = [];
-  for (const path10 of localMap.keys()) {
-    if (!remoteMap.has(path10)) {
-      deleteLocal.push(path10);
+  for (const path12 of localMap.keys()) {
+    if (!remoteMap.has(path12)) {
+      deleteLocal.push(path12);
     }
   }
   return { download, deleteLocal };
@@ -753,8 +739,8 @@ ${diagnostic ?? ""}`
     }
   }
   let deleted = 0;
-  for (const path10 of deleteLocal) {
-    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path10));
+  for (const path12 of deleteLocal) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path12));
     if (existsSync2(absPath)) {
       rmSync(absPath, { force: true });
       deleted += 1;
@@ -799,21 +785,21 @@ async function syncRepositoryProjectDocumentsPush(cfg, workdirPath, apmRoot) {
     ])
   );
   let synced = 0;
-  for (const path10 of localPaths) {
-    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path10));
+  for (const path12 of localPaths) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path12));
     const content = readFileSync3(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
-    if (remoteHashByPath.get(path10) === contentHash) {
+    if (remoteHashByPath.get(path12) === contentHash) {
       continue;
     }
     await api.cli.upsertRepositoryProjectDocument({
       repositoryId,
-      path: path10,
+      path: path12,
       content,
-      description: remoteDescriptionByPath.get(path10) ?? void 0
+      description: remoteDescriptionByPath.get(path12) ?? void 0
     });
     synced += 1;
-    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path10}`);
+    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path12}`);
   }
   if (synced === 0) {
     console.log("[apm] \u4ED3\u5E93\u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
@@ -1409,13 +1395,13 @@ async function downloadAttachment(cfg, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path10 = join6(dir, MANIFEST_FILE2);
-  if (!existsSync4(path10)) {
+  const path12 = join6(dir, MANIFEST_FILE2);
+  if (!existsSync4(path12)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync5(path10, "utf8")
+      readFileSync5(path12, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -1496,8 +1482,8 @@ function sanitizeSkillDirName(name) {
 function listBaseSkillDirNames() {
   if (!existsSync5(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();
+    const path12 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
+    return statSync2(path12).isDirectory();
   });
 }
 function syncAgentsGuide(apmDir) {
@@ -1509,8 +1495,8 @@ function syncAgentsGuide(apmDir) {
 function listBaseRuleFileNames() {
   if (!existsSync5(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();
+    const path12 = join7(BASE_RULES_TEMPLATE_DIR, name);
+    return statSync2(path12).isFile();
   });
 }
 function syncBaseRules(rulesDir) {
@@ -1573,13 +1559,13 @@ function ruleLocalFileName(ruleName) {
   return `${sanitized}.md`;
 }
 function loadManifest2(rulesDir) {
-  const path10 = join8(rulesDir, MANIFEST_FILE3);
-  if (!existsSync6(toFsPath(path10))) {
+  const path12 = join8(rulesDir, MANIFEST_FILE3);
+  if (!existsSync6(toFsPath(path12))) {
     return { version: 1, rules: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync6(toFsPath(path10), "utf8")
+      readFileSync6(toFsPath(path12), "utf8")
     );
     if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
       return parsed;
@@ -1760,8 +1746,12 @@ function registryBaseUrl() {
   const fromEnv = process.env.npm_config_registry?.trim() || process.env.NPM_CONFIG_REGISTRY?.trim();
   return (fromEnv || "https://registry.npmjs.org").replace(/\/+$/, "");
 }
-async function fetchLatestPublishedVersion() {
-  const url = `${registryBaseUrl()}/${CLI_PACKAGE_NAME}/latest`;
+function parseMajorVersion(version) {
+  const m = /^(\d+)/.exec(version.trim());
+  return m ? Number(m[1]) : 0;
+}
+async function fetchPublishedVersion(spec) {
+  const url = `${registryBaseUrl()}/${CLI_PACKAGE_NAME}/${spec}`;
   try {
     const res = await fetch(url);
     if (!res.ok) return null;
@@ -1771,28 +1761,73 @@ async function fetchLatestPublishedVersion() {
     return null;
   }
 }
+async function fetchLatestPublishedVersion() {
+  return fetchPublishedVersion("latest");
+}
+async function fetchLatestPublishedVersionInMajor(major) {
+  return fetchPublishedVersion(String(major));
+}
+function resolveUpdateTarget(input) {
+  const { current, allowMajorUpgrade, latestInMajor, globalLatest } = input;
+  const currentMajor = parseMajorVersion(current);
+  if (allowMajorUpgrade) {
+    if (globalLatest && globalLatest === current) {
+      return { action: "skip" };
+    }
+    return {
+      action: "install",
+      installSpec: `${CLI_PACKAGE_NAME}@latest`,
+      targetLabel: globalLatest ?? "latest",
+      expectedVersion: globalLatest,
+      majorUpgradeAvailable: null
+    };
+  }
+  if (latestInMajor && latestInMajor === current) {
+    return { action: "skip" };
+  }
+  const majorUpgradeAvailable = globalLatest && parseMajorVersion(globalLatest) > currentMajor ? globalLatest : null;
+  return {
+    action: "install",
+    installSpec: `${CLI_PACKAGE_NAME}@${currentMajor}`,
+    targetLabel: latestInMajor ?? String(currentMajor),
+    expectedVersion: latestInMajor,
+    majorUpgradeAvailable
+  };
+}
 function npmAvailable() {
   const r = runNpm(["--version"], { encoding: "utf8" });
   return !r.error && r.status === 0;
 }
-async function runUpdate() {
+async function runUpdate(options = {}) {
   const current = readCliVersion();
-  const latest = await fetchLatestPublishedVersion();
-  if (latest && current === latest) {
+  const currentMajor = parseMajorVersion(current);
+  const globalLatest = await fetchLatestPublishedVersion();
+  const latestInMajor = options.allowMajorUpgrade ? null : await fetchLatestPublishedVersionInMajor(currentMajor);
+  const resolved = resolveUpdateTarget({
+    current,
+    allowMajorUpgrade: options.allowMajorUpgrade,
+    latestInMajor,
+    globalLatest
+  });
+  if (resolved.action === "skip") {
     console.log(`[apm] \u5DF2\u662F\u6700\u65B0\u7248\u672C ${current}`);
     return { didUpdate: false };
   }
+  if (resolved.majorUpgradeAvailable) {
+    console.log(
+      `[apm] registry \u6700\u65B0\u4E3A ${resolved.majorUpgradeAvailable}\uFF08\u5927\u7248\u672C\u5347\u7EA7\uFF09\uFF0C\u672C\u6B21\u4EC5\u66F4\u65B0\u5230 ${currentMajor}.x\uFF1B\u4F7F\u7528 apm update --major \u53EF\u8DE8\u5927\u7248\u672C\u5347\u7EA7`
+    );
+  }
   if (!npmAvailable()) {
     console.error(
-      `[apm] \u672A\u627E\u5230 npm\u3002\u8BF7\u5B89\u88C5 Node.js \u540E\u6267\u884C\uFF1Anpm install -g ${CLI_PACKAGE_NAME}@latest`
+      `[apm] \u672A\u627E\u5230 npm\u3002\u8BF7\u5B89\u88C5 Node.js \u540E\u6267\u884C\uFF1Anpm install -g ${resolved.installSpec}`
     );
     process.exit(1);
   }
-  const targetLabel = latest ?? "latest";
   console.error(
-    `[apm] \u5F53\u524D\u7248\u672C ${current}\uFF0C\u6B63\u5728\u5B89\u88C5 ${CLI_PACKAGE_NAME}@${targetLabel} \u2026`
+    `[apm] \u5F53\u524D\u7248\u672C ${current}\uFF0C\u6B63\u5728\u5B89\u88C5 ${resolved.installSpec} \u2026` + (resolved.targetLabel !== current ? `\uFF08\u76EE\u6807 ${resolved.targetLabel}\uFF09` : "")
   );
-  const install = runNpm(["install", "-g", `${CLI_PACKAGE_NAME}@latest`], {
+  const install = runNpm(["install", "-g", resolved.installSpec], {
     stdio: "inherit"
   });
   if (install.error) {
@@ -1803,7 +1838,7 @@ async function runUpdate() {
     process.exit(install.status ?? 1);
   }
   const after = readCliVersion();
-  if (latest && after === latest) {
+  if (resolved.expectedVersion && after === resolved.expectedVersion) {
     console.log(`[apm] \u5DF2\u66F4\u65B0\u5230 ${after}`);
   } else {
     console.log(
@@ -2067,7 +2102,7 @@ async function runUpdateMessageStatus(options) {
 }
 
 // src/commands/connect.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import WebSocket from "ws";
 
 // src/ws/protocol.ts
@@ -2168,113 +2203,13 @@ function validateDeployPush(o) {
     }
   };
 }
-function validateCoordinatorDispatchMode(mode) {
-  return mode === "plan" || mode === "agent";
-}
-function validateCoordinatorDispatchPush(o) {
-  if (o.type !== "coordinator_dispatch") {
-    return { ok: false, reason: "\u671F\u671B coordinator_dispatch" };
-  }
-  if (!nonEmptyString(o.dispatchId)) {
-    return { ok: false, reason: "coordinator_dispatch \u7F3A\u5C11 dispatchId" };
-  }
-  if (!nonEmptyString(o.dispatchSessionId)) {
-    return { ok: false, reason: "coordinator_dispatch \u7F3A\u5C11 dispatchSessionId" };
-  }
-  if (!validateCoordinatorDispatchMode(o.mode)) {
-    return { ok: false, reason: "coordinator_dispatch.mode \u65E0\u6548" };
-  }
-  if (!nonEmptyString(o.content)) {
-    return { ok: false, reason: "coordinator_dispatch \u7F3A\u5C11 content" };
-  }
-  if (!nonEmptyString(o.model)) {
-    return { ok: false, reason: "coordinator_dispatch \u7F3A\u5C11 model" };
-  }
-  if (!nonEmptyString(o.apiKey)) {
-    return { ok: false, reason: "coordinator_dispatch \u7F3A\u5C11 apiKey" };
-  }
-  if (!nonEmptyString(o.workdir)) {
-    return { ok: false, reason: "coordinator_dispatch \u7F3A\u5C11 workdir" };
-  }
-  if (!nonEmptyString(o.user)) {
-    return { ok: false, reason: "coordinator_dispatch \u7F3A\u5C11 user" };
-  }
-  const data = {
-    type: "coordinator_dispatch",
-    dispatchId: o.dispatchId.trim(),
-    dispatchSessionId: o.dispatchSessionId.trim(),
-    mode: o.mode,
-    content: o.content,
-    model: o.model.trim(),
-    apiKey: o.apiKey.trim(),
-    workdir: o.workdir.trim(),
-    user: o.user.trim()
-  };
-  if (nonEmptyString(o.resumeAgentId)) {
-    data.resumeAgentId = o.resumeAgentId.trim();
-  }
-  return { ok: true, data };
-}
-function validateCoordinatorDispatchResumePush(o) {
-  if (o.type !== "coordinator_dispatch_resume") {
-    return { ok: false, reason: "\u671F\u671B coordinator_dispatch_resume" };
-  }
-  if (!nonEmptyString(o.dispatchId)) {
-    return { ok: false, reason: "coordinator_dispatch_resume \u7F3A\u5C11 dispatchId" };
-  }
-  if (!nonEmptyString(o.dispatchSessionId)) {
-    return {
-      ok: false,
-      reason: "coordinator_dispatch_resume \u7F3A\u5C11 dispatchSessionId"
-    };
-  }
-  if (!validateCoordinatorDispatchMode(o.mode)) {
-    return { ok: false, reason: "coordinator_dispatch_resume.mode \u65E0\u6548" };
-  }
-  if (!nonEmptyString(o.content)) {
-    return { ok: false, reason: "coordinator_dispatch_resume \u7F3A\u5C11 content" };
-  }
-  if (!nonEmptyString(o.resumeAgentId)) {
-    return {
-      ok: false,
-      reason: "coordinator_dispatch_resume \u7F3A\u5C11 resumeAgentId"
-    };
-  }
-  if (!nonEmptyString(o.model)) {
-    return { ok: false, reason: "coordinator_dispatch_resume \u7F3A\u5C11 model" };
-  }
-  if (!nonEmptyString(o.apiKey)) {
-    return { ok: false, reason: "coordinator_dispatch_resume \u7F3A\u5C11 apiKey" };
-  }
-  if (!nonEmptyString(o.workdir)) {
-    return { ok: false, reason: "coordinator_dispatch_resume \u7F3A\u5C11 workdir" };
-  }
-  if (!nonEmptyString(o.user)) {
-    return { ok: false, reason: "coordinator_dispatch_resume \u7F3A\u5C11 user" };
-  }
-  return {
-    ok: true,
-    data: {
-      type: "coordinator_dispatch_resume",
-      dispatchId: o.dispatchId.trim(),
-      dispatchSessionId: o.dispatchSessionId.trim(),
-      mode: o.mode,
-      content: o.content,
-      resumeAgentId: o.resumeAgentId.trim(),
-      model: o.model.trim(),
-      apiKey: o.apiKey.trim(),
-      workdir: o.workdir.trim(),
-      user: o.user.trim()
-    }
-  };
-}
 function validateAgentWsMessage(value, kind) {
   if (typeof value !== "object" || value === null) {
     return { ok: false, reason: "\u6D88\u606F\u4F53\u4E0D\u662F JSON \u5BF9\u8C61" };
   }
   const o = value;
   const type = o.type;
-  if (type !== "heartbeat" && type !== "message" && type !== "cancel" && type !== "deploy" && type !== "coordinator_dispatch" && type !== "coordinator_dispatch_resume") {
+  if (type !== "heartbeat" && type !== "message" && type !== "cancel" && type !== "deploy") {
     return { ok: false, reason: `\u672A\u77E5 type: ${String(type)}` };
   }
   if (kind === "heartbeat" || type === "heartbeat") {
@@ -2286,175 +2221,1098 @@ function validateAgentWsMessage(value, kind) {
   if (type === "deploy") {
     return validateDeployPush(o);
   }
-  if (type === "coordinator_dispatch") {
-    return validateCoordinatorDispatchPush(o);
-  }
-  if (type === "coordinator_dispatch_resume") {
-    return validateCoordinatorDispatchResumePush(o);
-  }
   return validateMessagePush(o);
 }
 
 // src/commands/connect/deploy-run.ts
 import { spawn } from "node:child_process";
-import { readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "node:fs";
 import { join as join13 } from "node:path";
-var DEPLOY_LOG_SYNC_INTERVAL_MS = 3e4;
-function readDeployConfig(workdir) {
-  const configPath = join13(workspaceApmDir(workdir), "apm.config.json");
+
+// src/commands/deploy/internal/wisdom-auto-deploy.ts
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import path3 from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+
+// src/commands/deploy/internal/apm-config.ts
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+function loadApmConfig(options) {
+  const p = resolve3(
+    process.cwd(),
+    options?.configPath ?? resolve3(workspaceApmDir(), "apm.config.json")
+  );
+  if (!existsSync11(p)) {
+    console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
+    process.exit(1);
+  }
   try {
-    const raw = readFileSync9(configPath, "utf8");
-    const parsed = JSON.parse(raw);
-    return parsed.deploy;
-  } catch {
-    return void 0;
+    const raw = readFileSync9(p, "utf8");
+    return JSON.parse(raw);
+  } catch (e) {
+    console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
+    process.exit(1);
   }
 }
-function resolveDeployCommand(workdir, environment) {
-  const command = readDeployConfig(workdir)?.[environment];
-  if (typeof command === "string" && command.trim()) {
-    return command.trim();
+function req(v, field) {
+  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
+    console.error(`apm.config.json \u4E2D backendDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    process.exit(1);
   }
-  return null;
-}
-function missingDeployCommandMessage(environment) {
-  return `deploy.${environment} \u90E8\u7F72\u547D\u4EE4\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u914D\u7F6E`;
+  return v;
 }
-function buildDeployLog(stdout, stderr) {
-  return [stdout, stderr].filter(Boolean).join("\n");
+function reqTopLevelName(cfg) {
+  const n = (cfg.name ?? "").trim();
+  if (!n) {
+    console.error(
+      "\u8BF7\u5728 apm.config.json \u9876\u5C42\u914D\u7F6E name\uFF08\u4E0E\u524D\u7AEF\u5236\u54C1\u524D\u7F00\u3001\u540E\u7AEF\u955C\u50CF\u540D\u5171\u7528\uFF09"
+    );
+    process.exit(1);
+  }
+  return n;
 }
-function runShellCommand(command, cwd, signal, onOutput) {
-  return new Promise((resolve5, reject) => {
-    const child = spawn(command, {
-      cwd,
-      shell: true,
-      env: process.env,
-      windowsHide: true
-    });
-    let stdout = "";
-    let stderr = "";
-    const emitLog = () => {
-      onOutput?.(buildDeployLog(stdout, stderr));
-    };
-    const onAbort = () => {
-      child.kill("SIGTERM");
-    };
-    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();
-    });
-    child.on("error", (error) => {
-      signal.removeEventListener("abort", onAbort);
-      reject(error);
-    });
-    child.on("close", (code) => {
-      signal.removeEventListener("abort", onAbort);
-      const log = buildDeployLog(stdout, stderr);
-      if (code === 0) {
-        resolve5({ log });
-        return;
-      }
-      const error = new Error(
-        `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${code ?? "unknown"}: ${command}`
-      );
-      error.log = log;
-      reject(error);
-    });
-  });
+function reqBackendPositiveInt(v, field) {
+  const n = Number(v);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
+    console.error(`apm.config.json \u4E2D backendDeploy.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
+    process.exit(1);
+  }
+  return n;
 }
-function createDeployLogSyncer(api, deploymentRunId) {
-  let lastSyncedLog = "";
-  let latestLog = "";
-  const syncIfChanged = async () => {
-    if (!latestLog || latestLog === lastSyncedLog) {
-      return;
-    }
-    await api.cli.syncCoordinatorDeploymentLog({
-      id: deploymentRunId,
-      log: latestLog
-    });
-    lastSyncedLog = latestLog;
-  };
-  const timer = setInterval(() => {
-    void syncIfChanged().catch((error) => {
+function resolveBackendDeployFromApmConfig(cfg) {
+  const b = cfg.backendDeploy ?? {};
+  const protoRaw = req(b.remoteProtocol, "remoteProtocol").trim().toLowerCase();
+  if (protoRaw !== "http" && protoRaw !== "https") {
+    console.error(
+      "apm.config.json \u4E2D backendDeploy.remoteProtocol \u53EA\u80FD\u4E3A http \u6216 https"
+    );
+    process.exit(1);
+  }
+  const remoteProtocol = protoRaw;
+  let mappings = [];
+  const rawPorts = b.containerPortsMappings;
+  if (rawPorts !== void 0 && rawPorts !== null) {
+    if (!Array.isArray(rawPorts)) {
       console.error(
-        "[apm] deploy log sync failed:",
-        error instanceof Error ? error.message : String(error)
+        "apm.config.json \u4E2D backendDeploy.containerPortsMappings \u987B\u4E3A\u5B57\u7B26\u4E32\u6570\u7EC4\uFF08\u53EF\u4E3A\u7A7A\uFF0C\u7701\u7565\u5219\u4E0D\u52A0\u7AEF\u53E3\u6620\u5C04\uFF09"
       );
-    });
-  }, DEPLOY_LOG_SYNC_INTERVAL_MS);
-  return {
-    updateLog(log) {
-      latestLog = log;
-    },
-    async flush() {
-      clearInterval(timer);
-      await syncIfChanged();
-    },
-    dispose() {
-      clearInterval(timer);
+      process.exit(1);
     }
+    mappings = rawPorts.map((x) => String(x).trim()).filter(Boolean);
+  }
+  return {
+    name: reqTopLevelName(cfg),
+    registryHost: req(b.registryHost, "registryHost").trim(),
+    registryNamespace: req(b.registryNamespace, "registryNamespace").trim(),
+    registryUser: req(b.registryUser, "registryUser").trim(),
+    registryPassword: req(b.registryPassword, "registryPassword").trim(),
+    remoteHost: req(b.remoteHost, "remoteHost").trim(),
+    remotePort: reqBackendPositiveInt(b.remotePort, "remotePort"),
+    remoteProtocol,
+    caPath: b.caPath?.trim(),
+    certPath: b.certPath?.trim(),
+    keyPath: b.keyPath?.trim(),
+    envFilePath: typeof b.envFilePath === "string" ? b.envFilePath.trim() : "",
+    containerPortsMappings: mappings,
+    dockerNetwork: b.dockerNetwork?.trim() || void 0
   };
 }
-async function handleInboundDeploy(cfg, msg, signal) {
-  const api = createApmApiClient(cfg);
-  const deploymentRunId = msg.deploymentRunId;
-  if (signal.aborted) return;
-  await api.cli.updateCoordinatorDeploymentStatus({
-    id: deploymentRunId,
-    status: "DEPLOYING"
-  });
-  const workdir = requireRemoteWorkdir(msg.workdir);
-  const command = resolveDeployCommand(workdir, msg.environment);
-  if (!command) {
-    const error = missingDeployCommandMessage(msg.environment);
-    console.error(`[apm] ${error}`);
-    await api.cli.completeCoordinatorDeployment({
-      id: deploymentRunId,
-      status: "FAILED",
-      log: error,
-      error
-    });
-    return;
+function reqFe(v, field) {
+  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
+    console.error(`apm.config.json \u4E2D frontendDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    process.exit(1);
   }
-  console.log(
-    `[apm] deploy start id=${deploymentRunId} env=${msg.environment} cwd=${workdir}`
+  return v;
+}
+function resolveFrontendDeployFromApmConfig(cfg) {
+  const f = cfg.frontendDeploy ?? {};
+  const port = Number(f.port);
+  return {
+    endpoint: reqFe(f.endpoint, "endpoint").trim(),
+    port: Number.isFinite(port) && port > 0 ? port : 9e3,
+    useSsl: Boolean(f.useSsl),
+    accessKey: reqFe(f.accessKey, "accessKey").trim(),
+    secretKey: reqFe(f.secretKey, "secretKey").trim(),
+    bucket: reqFe(f.bucket, "bucket").trim()
+  };
+}
+function reqWd(v, field) {
+  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
+    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    process.exit(1);
+  }
+  return v;
+}
+function reqWisdomPositiveInt(v, field) {
+  const n = Number(v);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
+    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
+    process.exit(1);
+  }
+  return n;
+}
+function resolveWisdomDeployFromApmConfig(cfg) {
+  const w = cfg.wisdomDeploy ?? {};
+  return {
+    host: reqWd(w.host, "host").trim(),
+    port: reqWisdomPositiveInt(w.port, "port"),
+    username: reqWd(w.username, "username").trim(),
+    password: reqWd(w.password, "password").trim(),
+    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 reqWb(v, field) {
+  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
+    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    process.exit(1);
+  }
+  return v;
+}
+function resolveWisdomBackendDeployFromApmConfig(cfg) {
+  const projectName = reqTopLevelName(cfg);
+  const w = cfg.wisdomDeploy ?? {};
+  const h = cfg.healthCheck ?? {};
+  const jarPath = reqWb(w.jarPath, "jarPath").trim();
+  const remoteAppDir = posixDirname(jarPath);
+  const healthPort = Number(reqHc(h.port, "port"));
+  const healthTimeout = Number(reqHc(h.timeout, "timeout"));
+  if (!Number.isFinite(healthPort) || !Number.isInteger(healthPort) || healthPort < 1) {
+    console.error("apm.config.json \u4E2D healthCheck.port \u987B\u4E3A\u6B63\u6574\u6570");
+    process.exit(1);
+  }
+  if (!Number.isFinite(healthTimeout) || !Number.isInteger(healthTimeout) || healthTimeout < 1) {
+    console.error("apm.config.json \u4E2D healthCheck.timeout \u987B\u4E3A\u6B63\u6574\u6570");
+    process.exit(1);
+  }
+  return {
+    projectName,
+    host: reqWd(w.host, "host").trim(),
+    port: reqWisdomPositiveInt(w.port, "port"),
+    username: reqWd(w.username, "username").trim(),
+    password: reqWd(w.password, "password").trim(),
+    remoteVueDistDir: reqWd(w.remotePath, "remotePath").trim(),
+    remoteAppDir,
+    remoteLibDir: `${remoteAppDir}/lib`,
+    startupJar: posixBasename(jarPath),
+    packageName: `${projectName}.jar.zip`,
+    mavenLocalRepo: reqWb(w.mavenLocalRepo, "mavenLocalRepo").trim(),
+    healthCheckPort: healthPort,
+    healthCheckContext: reqHc(h.context, "context").trim(),
+    healthCheckTimeout: healthTimeout
+  };
+}
+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/wisdom-backend-deploy.ts
+import {
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync5,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync10,
+  statSync as statSync5,
+  writeFileSync as writeFileSync10
+} from "node:fs";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import path2 from "node:path";
+import { Client } from "ssh2";
+import JSZip2 from "jszip";
+import SftpClient2 from "ssh2-sftp-client";
+
+// src/commands/deploy/internal/wisdom-sftp.ts
+import { readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import JSZip from "jszip";
+import SftpClient from "ssh2-sftp-client";
+async function addDirToZip(dir, zipFolder) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const folder = zipFolder.folder(entry.name);
+      if (folder) {
+        await addDirToZip(fullPath, folder);
+      }
+    } else {
+      const content = await readFile(fullPath);
+      zipFolder.file(entry.name, content);
+    }
+  }
+}
+async function zipDirectory(distDir, zipPath) {
+  console.error(`\u538B\u7F29\u76EE\u5F55: ${distDir}`);
+  const zip = new JSZip();
+  await addDirToZip(distDir, zip);
+  const content = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 }
+  });
+  await writeFile(zipPath, content);
+  const sizeMb = (content.length / 1024 / 1024).toFixed(2);
+  console.error(`\u5DF2\u751F\u6210: ${zipPath} (${sizeMb} MB)`);
+  return content.length;
+}
+async function ensureRemoteDir(sftp, dir) {
+  const parts = dir.replace(/\\/g, "/").split("/").filter(Boolean);
+  let current = dir.startsWith("/") ? "" : ".";
+  for (const part of parts) {
+    current = current ? `${current}/${part}` : `/${part}`;
+    try {
+      await sftp.mkdir(current, true);
+    } catch {
+    }
+  }
+}
+function execCommand(client, command) {
+  return new Promise((resolve5, reject) => {
+    client.exec(command, (err, stream) => {
+      if (err) return reject(err);
+      let stdout = "";
+      let stderr = "";
+      stream.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`\u8FDC\u7A0B\u547D\u4EE4\u5931\u8D25 (${code}): ${stderr || stdout}`));
+          return;
+        }
+        resolve5(stdout);
+      }).on("data", (data) => {
+        stdout += data.toString();
+      });
+      stream.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+    });
+  });
+}
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function buildClearRemoteDirExceptZipCommand(target) {
+  const normalized = target.replace(/\\/g, "/").replace(/\/$/, "");
+  const quotedTarget = shellSingleQuote(normalized);
+  const script = [
+    `T=${quotedTarget}`,
+    "S=$(mktemp -d)",
+    'while IFS= read -r -d "" z; do r="${z#${T}/}"',
+    'mkdir -p "${S}/$(dirname "$r")"',
+    'mv "$z" "${S}/${r}"',
+    'done < <(find "$T" -mindepth 1 -type f -iname "*.zip" -print0)',
+    'rm -rf "${T}"/*',
+    'while IFS= read -r -d "" r; do r="${r#./}"',
+    'mkdir -p "${T}/$(dirname "$r")"',
+    'mv "${S}/${r}" "${T}/${r}"',
+    'done < <(cd "$S" 2>/dev/null && find . -type f -print0)',
+    'rm -rf "$S"'
+  ].join("; ");
+  return `bash -c ${shellSingleQuote(script)}`;
+}
+async function uploadAndMaybeExtract(settings, localZip, extract) {
+  const remoteZipPath = `${settings.remotePath.replace(/\/$/, "")}/dist.zip`;
+  console.error(
+    `\u8FDE\u63A5 ${settings.username}@${settings.host}:${settings.port} ...`
+  );
+  const sftp = new SftpClient();
+  try {
+    await sftp.connect({
+      host: settings.host,
+      port: settings.port,
+      username: settings.username,
+      password: settings.password,
+      readyTimeout: 2e4,
+      tryKeyboard: true
+    });
+    await ensureRemoteDir(sftp, settings.remotePath);
+    await sftp.put(localZip, remoteZipPath);
+    console.error(`  \u2713 ${localZip} -> ${remoteZipPath}`);
+    if (extract) {
+      const target = settings.remotePath.replace(/\/$/, "");
+      const client = sftp.client;
+      const clearCmd = buildClearRemoteDirExceptZipCommand(target);
+      console.error(`\u8FDC\u7A0B\u6E05\u7406\u89E3\u538B\u76EE\u5F55: ${clearCmd}`);
+      await execCommand(client, clearCmd);
+      const unzipCmd = `unzip -o "${remoteZipPath}" -d "${target}"`;
+      console.error(`\u8FDC\u7A0B\u89E3\u538B: ${unzipCmd}`);
+      await execCommand(client, unzipCmd);
+      console.error("\u8FDC\u7A0B\u89E3\u538B\u5B8C\u6210!");
+    }
+    console.error(extract ? "\u90E8\u7F72\u5B8C\u6210!" : "\u4E0A\u4F20\u5B8C\u6210!");
+  } finally {
+    await sftp.end();
+  }
+}
+async function runWisdomSftpDeploy(params) {
+  const zipPath = path.join(params.localDir, "..", ".deploy-sftp-dist.zip");
+  const resolvedZipPath = path.resolve(zipPath);
+  let zipSizeBytes = 0;
+  try {
+    zipSizeBytes = await zipDirectory(params.localDir, resolvedZipPath);
+    await uploadAndMaybeExtract(
+      params.settings,
+      resolvedZipPath,
+      params.extract
+    );
+  } finally {
+    try {
+      await unlink(resolvedZipPath);
+      console.error(`\u5DF2\u6E05\u7406\u672C\u5730\u4E34\u65F6\u6587\u4EF6: ${resolvedZipPath}`);
+    } catch {
+    }
+  }
+  return {
+    ok: true,
+    localDir: params.localDir,
+    host: params.settings.host,
+    remotePath: params.settings.remotePath,
+    zipSizeBytes,
+    extracted: params.extract
+  };
+}
+
+// src/commands/deploy/internal/wisdom-backend-deploy.ts
+var SPRINGBOOT_SCRIPT = "springboot.sh";
+var MAVEN_MODULE = "jeecg-module-system/jeecg-system-start";
+var MAVEN_PROFILE = "dev";
+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.error(`[${hh}:${mm}:${ss}] ${message}`);
+}
+function fail(message) {
+  log(`ERROR: ${message}`);
+  process.exit(1);
+}
+function expandPath(pathStr) {
+  return path2.resolve(pathStr.replace(/^~(?=\/|$)/, process.env.HOME ?? ""));
+}
+function deployCacheDir() {
+  return path2.join(workspaceApmDir(), "deploy", ".deploy_cache");
+}
+function manifestFilePath() {
+  return path2.join(deployCacheDir(), "manifest.json");
+}
+function getTargetDir(projectRoot) {
+  return path2.join(projectRoot, MAVEN_MODULE, "target");
+}
+function relativeKey(projectRoot, filePath) {
+  return path2.relative(projectRoot, filePath).split(path2.sep).join("/");
+}
+function fileSignature(filePath) {
+  const stat2 = statSync5(filePath);
+  return { size: stat2.size, mtime: stat2.mtimeMs / 1e3 };
+}
+function loadManifest3() {
+  const manifestPath2 = manifestFilePath();
+  if (!existsSync12(manifestPath2)) {
+    return {};
+  }
+  return JSON.parse(readFileSync10(manifestPath2, "utf8"));
+}
+function saveManifest3(manifest) {
+  const dir = deployCacheDir();
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync10(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
+}
+function isProjectLibJar(jarName) {
+  return jarName.startsWith("jeecg-");
+}
+function shouldUploadLibFile(localPath, remoteAttr, manifest, projectRoot) {
+  if (!remoteAttr) {
+    return [false, "\u8FDC\u7A0B\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7"];
+  }
+  const localSize = statSync5(localPath).size;
+  const remoteSize = remoteAttr.size;
+  if (localSize !== remoteSize) {
+    return [true, `\u5927\u5C0F\u53D8\u5316 ${remoteSize} -> ${localSize}`];
+  }
+  if (isProjectLibJar(path2.basename(localPath)) && manifest) {
+    const key = relativeKey(projectRoot, localPath);
+    const current = fileSignature(localPath);
+    const previous = manifest[key];
+    if (!previous) {
+      return [true, "\u9879\u76EE\u6A21\u5757\u672A\u8BB0\u5F55"];
+    }
+    if (previous.size !== current.size) {
+      return [true, "\u9879\u76EE\u6A21\u5757\u5927\u5C0F\u53D8\u5316"];
+    }
+    if (previous.mtime < current.mtime) {
+      return [true, "\u9879\u76EE\u6A21\u5757\u91CD\u65B0\u6784\u5EFA"];
+    }
+  }
+  return [false, "\u5927\u5C0F\u4E00\u81F4\uFF0C\u8DF3\u8FC7"];
+}
+function listLibFilesToUpload(localLibDir, remoteStats, projectRoot, manifest = null) {
+  const entries = [];
+  const jarFiles = readdirSync5(localLibDir).filter((name) => name.endsWith(".jar")).sort();
+  for (const jarName of jarFiles) {
+    const jarPath = path2.join(localLibDir, jarName);
+    const remoteAttr = remoteStats.get(jarName);
+    const [shouldUpload, reason] = shouldUploadLibFile(
+      jarPath,
+      remoteAttr,
+      manifest,
+      projectRoot
+    );
+    if (shouldUpload) {
+      entries.push({ path: jarPath, arcname: jarName, reason });
+    }
+  }
+  return entries;
+}
+function updateManifestEntries(manifest, entries, projectRoot) {
+  for (const entry of entries) {
+    manifest[relativeKey(projectRoot, entry.path)] = fileSignature(entry.path);
+  }
+  return manifest;
+}
+async function createUpdatePackage(entries, packageName) {
+  const dir = deployCacheDir();
+  mkdirSync5(dir, { recursive: true });
+  const zipPath = path2.join(dir, packageName);
+  log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path2.basename(zipPath)}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
+  const zip = new JSZip2();
+  for (const entry of entries) {
+    const content = readFileSync10(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 }
+  });
+  writeFileSync10(zipPath, buffer);
+  return zipPath;
+}
+function getMvnExecutable() {
+  const isWin = process.platform === "win32";
+  const candidates = isWin ? ["mvn.cmd", "mvn.bat", "mvn"] : ["mvn"];
+  for (const name of candidates) {
+    const result = spawnSync2(isWin ? "where" : "which", [name], {
+      encoding: "utf8"
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+      return result.stdout.trim().split(/\r?\n/)[0];
+    }
+  }
+  fail("\u672A\u627E\u5230 mvn \u547D\u4EE4\uFF0C\u8BF7\u786E\u8BA4 Maven \u5DF2\u5B89\u88C5\u5E76\u52A0\u5165 PATH");
+}
+function runMavenBuild(projectRoot, mavenLocalRepo) {
+  const mavenRepo = expandPath(mavenLocalRepo);
+  const cmd = [
+    getMvnExecutable(),
+    "clean",
+    "package",
+    `-P${MAVEN_PROFILE}`,
+    `-Dmaven.repo.local=${mavenRepo}`,
+    "-DskipTests"
+  ];
+  log(`\u5F00\u59CB Maven \u6784\u5EFA: ${cmd.join(" ")}`);
+  log(`Maven \u672C\u5730\u4ED3\u5E93: ${mavenRepo}`);
+  const result = spawnSync2(cmd[0], cmd.slice(1), {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    fail(`Maven \u6784\u5EFA\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${result.status ?? 1}`);
+  }
+}
+function locateLibDir(projectRoot) {
+  const targetDir = getTargetDir(projectRoot);
+  if (!existsSync12(targetDir)) {
+    fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
+  }
+  const libDir = path2.join(targetDir, "lib");
+  if (!existsSync12(libDir) || !statSync5(libDir).isDirectory()) {
+    fail(`lib \u76EE\u5F55\u4E0D\u5B58\u5728: ${libDir}`);
+  }
+  const libJars = readdirSync5(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 connectSsh(config) {
+  const client = new Client();
+  log(`\u8FDE\u63A5\u670D\u52A1\u5668 ${config.username}@${config.host}:${config.port}`);
+  await new Promise((resolve5, reject) => {
+    client.on("ready", () => resolve5()).on("error", (err) => reject(err)).connect({
+      host: config.host,
+      port: config.port,
+      username: config.username,
+      password: config.password,
+      readyTimeout: 3e4,
+      tryKeyboard: true
+    });
+  });
+  const sftp = new SftpClient2();
+  await sftp.connect({
+    host: config.host,
+    port: config.port,
+    username: config.username,
+    password: config.password,
+    readyTimeout: 3e4,
+    tryKeyboard: true
+  });
+  return { client, sftp };
+}
+async function closeSsh(conn) {
+  try {
+    await conn.sftp.end();
+  } catch {
+  }
+  conn.client.end();
+}
+async function getRemoteFileStats(sftp, remoteDir) {
+  const stats = /* @__PURE__ */ new Map();
+  try {
+    const listing = await sftp.list(remoteDir);
+    for (const item of listing) {
+      if (item.name.endsWith(".jar")) {
+        stats.set(item.name, { filename: item.name, size: item.size });
+      }
+    }
+  } catch {
+  }
+  return stats;
+}
+async function uploadUpdatePackage(sftp, zipPath, config) {
+  const remoteDir = config.remoteVueDistDir.replace(/\/$/, "");
+  const remotePath = `${remoteDir}/${path2.basename(zipPath)}`;
+  log(`\u4E0A\u4F20\u66F4\u65B0\u5305 -> ${remotePath}`);
+  try {
+    await sftp.fastPut(zipPath, remotePath);
+    log("\u66F4\u65B0\u5305\u4E0A\u4F20\u6210\u529F");
+  } catch (err) {
+    fail(`\u66F4\u65B0\u5305\u4E0A\u4F20\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
+  }
+  return remotePath;
+}
+async function runRemoteCommand(client, command, options) {
+  const check = options?.check ?? true;
+  const stream = options?.stream ?? false;
+  log(`\u8FDC\u7A0B\u6267\u884C: ${command}`);
+  return new Promise((resolve5, reject) => {
+    client.exec(command, (err, execStream) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      let out = "";
+      let errText = "";
+      execStream.on("data", (data) => {
+        const text = data.toString();
+        out += text;
+        if (stream) {
+          process.stdout.write(text);
+        }
+      });
+      execStream.stderr.on("data", (data) => {
+        errText += data.toString();
+      });
+      execStream.on("close", (code) => {
+        if (!stream) {
+          if (out) {
+            console.log(out.trimEnd());
+          }
+          if (errText) {
+            console.error(errText.trimEnd());
+          }
+        } else if (out && !out.endsWith("\n")) {
+          process.stdout.write("\n");
+        }
+        if (check && code !== 0) {
+          fail(`\u8FDC\u7A0B\u547D\u4EE4\u5931\u8D25 (exit ${code}): ${command}`);
+        }
+        resolve5({ exitCode: code, out: out.trim(), err: errText.trim() });
+      });
+    });
+  });
+}
+function buildExtractUpdatePackageScript(remoteZipPath, remoteLibDir) {
+  const quotedZip = shellSingleQuote(remoteZipPath);
+  const quotedLib = shellSingleQuote(remoteLibDir);
+  return `
+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"
+`.trim();
+}
+async function extractUpdatePackageOnRemote(client, config, remoteZipPath) {
+  const script = buildExtractUpdatePackageScript(
+    remoteZipPath,
+    config.remoteLibDir
+  );
+  const { out } = await runRemoteCommand(client, script);
+  const match = out.match(/UPDATED_COUNT=(\d+)/);
+  if (!match) {
+    fail(`\u8FDC\u7A0B\u89E3\u538B\u5931\u8D25\uFF0C\u672A\u83B7\u53D6\u66F4\u65B0\u6570\u91CF
+\u8F93\u51FA: ${out || "(\u7A7A)"}`);
+  }
+  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, config, 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 quotedArgs = [action, ...args].map((arg) => shellSingleQuote(arg));
+  const command = [
+    `cd ${shellSingleQuote(config.remoteAppDir)}`,
+    `./${SPRINGBOOT_SCRIPT} ${quotedArgs.join(" ")}`
+  ].join(" && ");
+  const { exitCode, out, err } = await runRemoteCommand(client, command, {
+    check: false
+  });
+  const combined = `${out}
+${err}`.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;
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
+}
+async function getRunningJar(client, config) {
+  const combined = await runSpringbootAction(
+    client,
+    config,
+    "status",
+    config.startupJar
+  );
+  const text = stripAnsi(combined).trim().toLowerCase();
+  if (text.includes("not running")) {
+    return null;
+  }
+  if (text.includes("running")) {
+    return config.startupJar;
+  }
+  return null;
+}
+async function healthCheckService(client, config) {
+  const port = String(config.healthCheckPort);
+  const context = config.healthCheckContext;
+  const timeout = String(config.healthCheckTimeout);
+  log(`\u5065\u5EB7\u68C0\u67E5: springboot.sh health ${port} ${context} ${timeout}`);
+  await runSpringbootAction(client, config, "health", port, context, timeout);
+}
+async function runWisdomBackendDeploy(options) {
+  const projectRoot = path2.resolve(options.projectRoot ?? process.cwd());
+  const config = options.config;
+  log(`=== \u81EA\u52A8\u90E8\u7F72: ${config.projectName} ===`);
+  log(`\u914D\u7F6E\u6587\u4EF6: ${path2.join(workspaceApmDir(), "apm.config.json")}`);
+  log(`\u9879\u76EE\u6839\u76EE\u5F55: ${projectRoot}`);
+  if (!options.skipMaven) {
+    runMavenBuild(projectRoot, config.mavenLocalRepo);
+  }
+  const libDir = locateLibDir(projectRoot);
+  let manifest = loadManifest3();
+  const conn = await connectSsh(config);
+  try {
+    const remoteLibStats = await getRemoteFileStats(
+      conn.sftp,
+      config.remoteLibDir
+    );
+    log("\u6536\u96C6 JAR \u66F4\u65B0...");
+    const libUploadEntries = listLibFilesToUpload(
+      libDir,
+      remoteLibStats,
+      projectRoot,
+      manifest
+    );
+    let updated = 0;
+    if (libUploadEntries.length > 0) {
+      const zipPath = await createUpdatePackage(
+        libUploadEntries,
+        config.packageName
+      );
+      const remoteZipPath = await uploadUpdatePackage(
+        conn.sftp,
+        zipPath,
+        config
+      );
+      log("\u8FDC\u7A0B\u89E3\u538B lib \u76EE\u5F55\uFF08\u4EC5\u8986\u76D6\u5DF2\u6709 JAR\uFF09...");
+      updated = await extractUpdatePackageOnRemote(
+        conn.client,
+        config,
+        remoteZipPath
+      );
+    } else {
+      log("\u65E0 JAR \u9700\u8981\u66F4\u65B0\uFF0C\u8DF3\u8FC7\u66F4\u65B0\u5305\u4E0A\u4F20");
+    }
+    const runningJar = await getRunningJar(conn.client, config);
+    let 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(
+        conn.client,
+        config,
+        "restart",
+        config.startupJar
+      );
+    }
+    await healthCheckService(conn.client, config);
+    if (libUploadEntries.length > 0) {
+      manifest = updateManifestEntries(manifest, libUploadEntries, projectRoot);
+      saveManifest3(manifest);
+    }
+  } finally {
+    await closeSsh(conn);
+  }
+  log("\u90E8\u7F72\u5B8C\u6210");
+}
+
+// src/commands/deploy/internal/wisdom-auto-deploy.ts
+function isWisdomLegacyDeploy(cfg) {
+  const w = cfg.wisdomDeploy;
+  if (!w?.host?.trim() || !w.remotePath?.trim()) {
+    return false;
+  }
+  const hasNewFrontend = Boolean(cfg.frontendDeploy?.endpoint?.trim());
+  const hasNewBackend = Boolean(cfg.backendDeploy?.registryHost?.trim());
+  return !hasNewFrontend && !hasNewBackend;
+}
+function detectWisdomProjectType(cwd) {
+  return existsSync13(path3.join(cwd, "package.json")) ? "frontend" : "backend";
+}
+function readPackageScripts(cwd) {
+  const pkgPath = path3.join(cwd, "package.json");
+  if (!existsSync13(pkgPath)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync11(pkgPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.scripts ?? {};
+  } catch {
+    return {};
+  }
+}
+function resolveFrontendDeployCommand(env, cwd) {
+  const scripts = readPackageScripts(cwd);
+  const deployKey = `deploy:${env}`;
+  if (scripts[deployKey]?.trim()) {
+    return `npm run deploy:${env}`;
+  }
+  return null;
+}
+function runShellCommand(command, cwd) {
+  console.error(`==> ${command}`);
+  const result = spawnSync3(command, {
+    cwd,
+    stdio: "inherit",
+    shell: true,
+    env: process.env
+  });
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+async function runWisdomAutoDeploy(options) {
+  const cwd = path3.resolve(options.cwd ?? process.cwd());
+  const projectType = detectWisdomProjectType(cwd);
+  console.error(
+    `[apm] \u533B\u52A1\u5B58\u91CF\u9879\u76EE\u81EA\u52A8\u8BC6\u522B: ${projectType === "frontend" ? "\u524D\u7AEF Vue" : "\u540E\u7AEF Java"}`
+  );
+  if (projectType === "frontend") {
+    const deployCmd = resolveFrontendDeployCommand(options.env, cwd);
+    if (!deployCmd) {
+      console.error(
+        `\u524D\u7AEF\u9879\u76EE ${path3.join(cwd, "package.json")} \u4E2D\u672A\u627E\u5230 deploy:${options.env} \u811A\u672C`
+      );
+      process.exit(1);
+    }
+    runShellCommand(deployCmd, cwd);
+    return { projectType };
+  }
+  const configPath = options.configPath ?? path3.join(workspaceApmDir(cwd), "apm.config.json");
+  const cfg = loadApmConfig({ configPath });
+  const settings = resolveWisdomBackendDeployFromApmConfig(cfg);
+  await runWisdomBackendDeploy({
+    config: settings,
+    projectRoot: cwd,
+    skipMaven: Boolean(options.skipMaven)
+  });
+  return { projectType };
+}
+
+// src/commands/connect/deploy-run.ts
+var DEPLOY_LOG_SYNC_INTERVAL_MS = 3e4;
+function readApmConfig(workdir) {
+  const configPath = join13(workspaceApmDir(workdir), "apm.config.json");
+  if (!existsSync14(configPath)) {
+    return void 0;
+  }
+  try {
+    const raw = readFileSync12(configPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function readDeployConfig(workdir) {
+  return readApmConfig(workdir)?.deploy;
+}
+function resolveDeployCommand(workdir, environment) {
+  const command = readDeployConfig(workdir)?.[environment];
+  if (typeof command === "string" && command.trim()) {
+    return command.trim();
+  }
+  return null;
+}
+function missingDeployCommandMessage(environment) {
+  return `deploy.${environment} \u90E8\u7F72\u547D\u4EE4\u672A\u914D\u7F6E\uFF0C\u8BF7\u5148\u914D\u7F6E`;
+}
+function buildDeployLog(stdout, stderr) {
+  return [stdout, stderr].filter(Boolean).join("\n");
+}
+function runShellCommand2(command, cwd, signal, onOutput) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      env: process.env,
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    const emitLog = () => {
+      onOutput?.(buildDeployLog(stdout, stderr));
+    };
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    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();
+    });
+    child.on("error", (error) => {
+      signal.removeEventListener("abort", onAbort);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      signal.removeEventListener("abort", onAbort);
+      const log2 = buildDeployLog(stdout, stderr);
+      if (code === 0) {
+        resolve5({ log: log2 });
+        return;
+      }
+      const error = new Error(
+        `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${code ?? "unknown"}: ${command}`
+      );
+      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(log2) {
+      latestLog = log2;
+    },
+    async flush() {
+      clearInterval(timer);
+      await syncIfChanged();
+    },
+    dispose() {
+      clearInterval(timer);
+    }
+  };
+}
+async function handleInboundDeploy(cfg, msg, signal) {
+  const api = createApmApiClient(cfg);
+  const deploymentRunId = msg.deploymentRunId;
+  if (signal.aborted) return;
+  await api.cli.updateTaskDeploymentStatus({
+    id: deploymentRunId,
+    status: "DEPLOYING"
+  });
+  const workdir = requireRemoteWorkdir(msg.workdir);
+  const apmConfig = readApmConfig(workdir);
+  if (apmConfig && isWisdomLegacyDeploy(apmConfig)) {
+    console.log(
+      `[apm] deploy start id=${deploymentRunId} env=${msg.environment} cwd=${workdir} (wisdom auto)`
+    );
+    const logSyncer2 = createDeployLogSyncer(api, deploymentRunId);
+    try {
+      await runWisdomAutoDeploy({
+        env: msg.environment,
+        cwd: workdir
+      });
+      await logSyncer2.flush();
+      await api.cli.completeTaskDeployment({
+        id: deploymentRunId,
+        status: "SUCCESS",
+        log: "\u533B\u52A1\u5B58\u91CF\u9879\u76EE\u81EA\u52A8\u90E8\u7F72\u5B8C\u6210"
+      });
+      console.log(`[apm] deploy success id=${deploymentRunId}`);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      await logSyncer2.flush();
+      await api.cli.completeTaskDeployment({
+        id: deploymentRunId,
+        status: "FAILED",
+        log: detail,
+        error: detail
+      });
+      console.error(`[apm] deploy failed id=${deploymentRunId}: ${detail}`);
+    } finally {
+      logSyncer2.dispose();
+    }
+    return;
+  }
+  const command = resolveDeployCommand(workdir, msg.environment);
+  if (!command) {
+    const error = missingDeployCommandMessage(msg.environment);
+    console.error(`[apm] ${error}`);
+    await api.cli.completeTaskDeployment({
+      id: deploymentRunId,
+      status: "FAILED",
+      log: error,
+      error
+    });
+    return;
+  }
+  console.log(
+    `[apm] deploy start id=${deploymentRunId} env=${msg.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 runShellCommand2(command, workdir, signal, (log3) => {
+      latestLog = log3;
+      logSyncer.updateLog(log3);
     });
-    latestLog = log;
-    logSyncer.updateLog(log);
+    latestLog = log2;
+    logSyncer.updateLog(log2);
     await logSyncer.flush();
-    await api.cli.completeCoordinatorDeployment({
+    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.completeCoordinatorDeployment({
+    await api.cli.completeTaskDeployment({
       id: deploymentRunId,
       status: "FAILED",
-      log,
+      log: log2,
       error: detail
     });
     console.error(`[apm] deploy failed id=${deploymentRunId}: ${detail}`);
@@ -2463,6 +3321,69 @@ async function handleInboundDeploy(cfg, msg, signal) {
   }
 }
 
+// src/commands/connect/abort-signal-debug.ts
+import {
+  getEventListeners,
+  getMaxListeners,
+  setMaxListeners
+} from "node:events";
+function isAbortSignalDebugEnabled() {
+  const v = process.env.APM_DEBUG_ABORT_SIGNAL?.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes";
+}
+function formatAbortSignalStats(signal, label) {
+  if (!signal) {
+    return `[apm:abort-debug] ${label}: (no signal)`;
+  }
+  const listeners = getEventListeners(signal, "abort");
+  const max = getMaxListeners(signal);
+  return `[apm:abort-debug] ${label}: abortListeners=${listeners.length} maxListeners=${max} aborted=${signal.aborted}`;
+}
+function logAbortSignalStats(signal, label) {
+  if (!isAbortSignalDebugEnabled()) return;
+  console.log(formatAbortSignalStats(signal, label));
+}
+var installed = false;
+function installAbortSignalDebug() {
+  if (!isAbortSignalDebugEnabled() || installed) return;
+  installed = true;
+  const maxFromEnv = Number.parseInt(
+    process.env.APM_ABORT_SIGNAL_MAX_LISTENERS ?? "",
+    10
+  );
+  if (Number.isFinite(maxFromEnv) && maxFromEnv > 0) {
+    setMaxListeners(maxFromEnv);
+    console.log(
+      `[apm:abort-debug] setMaxListeners(${maxFromEnv}) via APM_ABORT_SIGNAL_MAX_LISTENERS`
+    );
+  }
+  process.on("warning", (warning) => {
+    if (warning.name !== "MaxListenersExceededWarning") return;
+    console.warn(`[apm:abort-debug] ${warning.name}: ${warning.message}`);
+    if (warning.stack) {
+      console.warn(warning.stack);
+    }
+  });
+  const proto = AbortSignal.prototype;
+  const original = proto.addEventListener;
+  proto.addEventListener = function(type, listener, options) {
+    if (type === "abort") {
+      const sig = this;
+      const before = getEventListeners(sig, "abort").length;
+      const max = getMaxListeners(sig);
+      const stack = new Error("[apm:abort-debug] addEventListener stack").stack?.split("\n").slice(2, 8).join("\n") ?? "";
+      console.log(
+        `[apm:abort-debug] addEventListener("abort") before=${before} max=${max}
+${stack}`
+      );
+    }
+    return original.call(this, type, listener, options);
+  };
+  console.log(
+    "[apm:abort-debug] \u5DF2\u542F\u7528 AbortSignal \u8C03\u8BD5\uFF08APM_DEBUG_ABORT_SIGNAL\uFF09"
+  );
+}
+
 // src/commands/connect/cursor-agent.ts
 import {
   Agent,
@@ -2667,17 +3588,17 @@ ${JSON.stringify(event, null, 2)}
 }
 
 // src/commands/connect/agent-session-registry.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname4, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname4, resolve as resolve4 } from "node:path";
 function registryPath(workdir, sessionId) {
-  return resolve3(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
+  return resolve4(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
 }
-function readRegistry(path10) {
-  if (!existsSync11(path10)) {
+function readRegistry(path12) {
+  if (!existsSync15(path12)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync10(path10, "utf8"));
+    const parsed = JSON.parse(readFileSync13(path12, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const result = {};
       for (const [key, value] of Object.entries(
@@ -2693,9 +3614,9 @@ function readRegistry(path10) {
   }
   return {};
 }
-function writeRegistry(path10, registry) {
-  mkdirSync5(dirname4(path10), { recursive: true });
-  writeFileSync10(path10, `${JSON.stringify(registry, null, 2)}
+function writeRegistry(path12, registry) {
+  mkdirSync6(dirname4(path12), { recursive: true });
+  writeFileSync11(path12, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function loadSessionAgentId(workdir, sessionId, user) {
@@ -2703,19 +3624,19 @@ function loadSessionAgentId(workdir, sessionId, user) {
   return registry[user];
 }
 function saveSessionAgentId(workdir, sessionId, user, agentId) {
-  const path10 = registryPath(workdir, sessionId);
-  const registry = readRegistry(path10);
+  const path12 = registryPath(workdir, sessionId);
+  const registry = readRegistry(path12);
   registry[user] = agentId;
-  writeRegistry(path10, registry);
+  writeRegistry(path12, registry);
 }
 function clearSessionAgentId(workdir, sessionId, user) {
-  const path10 = registryPath(workdir, sessionId);
-  const registry = readRegistry(path10);
+  const path12 = registryPath(workdir, sessionId);
+  const registry = readRegistry(path12);
   if (!(user in registry)) {
     return;
   }
   delete registry[user];
-  writeRegistry(path10, registry);
+  writeRegistry(path12, registry);
 }
 
 // src/commands/connect/cursor-message-log.ts
@@ -2740,148 +3661,57 @@ function createThrottledCursorMessageLogSync(cfg, ctx, onError) {
   };
   const drainDirtyEvents = async (session) => {
     while (session.getDirtyEvents().length > 0) {
-      await syncDirtyEventsOnce(session);
-    }
-  };
-  const enqueueSync = (session) => {
-    syncChain = syncChain.then(() => drainDirtyEvents(session));
-  };
-  return {
-    schedule(session) {
-      latestSession = session;
-      const now = Date.now();
-      const elapsed = now - lastRunAt;
-      if (elapsed >= CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS) {
-        if (timer) {
-          clearTimeout(timer);
-          timer = void 0;
-        }
-        enqueueSync(session);
-        return;
-      }
-      if (timer) {
-        return;
-      }
-      timer = setTimeout(() => {
-        timer = void 0;
-        enqueueSync(latestSession);
-      }, CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS - elapsed);
-    },
-    async flush(session) {
-      latestSession = session;
-      if (timer) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-      await syncChain;
-      await drainDirtyEvents(session);
-    }
-  };
-}
-async function syncCursorMessageLog(cfg, ctx, events) {
-  const agentId = ctx.agentId.trim();
-  if (!agentId || events.length === 0) {
-    return;
-  }
-  const api = createApmApiClient(cfg);
-  await api.cli.upsertCursorMessageLog({
-    sessionId: ctx.sessionId,
-    messageId: ctx.messageId,
-    agentId,
-    events
-  });
-}
-
-// src/commands/connect/abort-signal-debug.ts
-import {
-  getEventListeners,
-  getMaxListeners,
-  setMaxListeners
-} from "node:events";
-function isAbortSignalDebugEnabled() {
-  const v = process.env.APM_DEBUG_ABORT_SIGNAL?.trim().toLowerCase();
-  return v === "1" || v === "true" || v === "yes";
-}
-function formatAbortSignalStats(signal, label) {
-  if (!signal) {
-    return `[apm:abort-debug] ${label}: (no signal)`;
-  }
-  const listeners = getEventListeners(signal, "abort");
-  const max = getMaxListeners(signal);
-  return `[apm:abort-debug] ${label}: abortListeners=${listeners.length} maxListeners=${max} aborted=${signal.aborted}`;
-}
-function logAbortSignalStats(signal, label) {
-  if (!isAbortSignalDebugEnabled()) return;
-  console.log(formatAbortSignalStats(signal, label));
-}
-var installed = false;
-function installAbortSignalDebug() {
-  if (!isAbortSignalDebugEnabled() || installed) return;
-  installed = true;
-  const maxFromEnv = Number.parseInt(
-    process.env.APM_ABORT_SIGNAL_MAX_LISTENERS ?? "",
-    10
-  );
-  if (Number.isFinite(maxFromEnv) && maxFromEnv > 0) {
-    setMaxListeners(maxFromEnv);
-    console.log(
-      `[apm:abort-debug] setMaxListeners(${maxFromEnv}) via APM_ABORT_SIGNAL_MAX_LISTENERS`
-    );
-  }
-  process.on("warning", (warning) => {
-    if (warning.name !== "MaxListenersExceededWarning") return;
-    console.warn(`[apm:abort-debug] ${warning.name}: ${warning.message}`);
-    if (warning.stack) {
-      console.warn(warning.stack);
-    }
-  });
-  const proto = AbortSignal.prototype;
-  const original = proto.addEventListener;
-  proto.addEventListener = function(type, listener, options) {
-    if (type === "abort") {
-      const sig = this;
-      const before = getEventListeners(sig, "abort").length;
-      const max = getMaxListeners(sig);
-      const stack = new Error("[apm:abort-debug] addEventListener stack").stack?.split("\n").slice(2, 8).join("\n") ?? "";
-      console.log(
-        `[apm:abort-debug] addEventListener("abort") before=${before} max=${max}
-${stack}`
-      );
-    }
-    return original.call(this, type, listener, options);
-  };
-  console.log(
-    "[apm:abort-debug] \u5DF2\u542F\u7528 AbortSignal \u8C03\u8BD5\uFF08APM_DEBUG_ABORT_SIGNAL\uFF09"
-  );
-}
-
-// src/commands/connect/append-dispatch-response-tool.ts
-function createAppendDispatchResponseTools(cfg, dispatchId) {
-  return {
-    append_dispatch_response: {
-      description: "Append content to the coordinator member dispatch response for the coordinator Agent to read.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          content: { type: "string", description: "Response text to append" }
-        },
-        required: ["content"]
-      },
-      execute: async (args) => {
-        const content = String(args.content ?? "").trim();
-        if (!content) {
-          return "content \u4E0D\u80FD\u4E3A\u7A7A";
+      await syncDirtyEventsOnce(session);
+    }
+  };
+  const enqueueSync = (session) => {
+    syncChain = syncChain.then(() => drainDirtyEvents(session));
+  };
+  return {
+    schedule(session) {
+      latestSession = session;
+      const now = Date.now();
+      const elapsed = now - lastRunAt;
+      if (elapsed >= CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = void 0;
         }
-        const api = createApmApiClient(cfg);
-        await api.cli.appendCoordinatorDispatchResponse({
-          id: dispatchId,
-          content
-        });
-        return `\u5DF2\u8FFD\u52A0\u6D3E\u53D1\u54CD\u5E94\uFF08${content.length} \u5B57\u7B26\uFF09`;
+        enqueueSync(session);
+        return;
+      }
+      if (timer) {
+        return;
+      }
+      timer = setTimeout(() => {
+        timer = void 0;
+        enqueueSync(latestSession);
+      }, CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS - elapsed);
+    },
+    async flush(session) {
+      latestSession = session;
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
       }
+      await syncChain;
+      await drainDirtyEvents(session);
     }
   };
 }
+async function syncCursorMessageLog(cfg, ctx, events) {
+  const agentId = ctx.agentId.trim();
+  if (!agentId || events.length === 0) {
+    return;
+  }
+  const api = createApmApiClient(cfg);
+  await api.cli.upsertCursorMessageLog({
+    sessionId: ctx.sessionId,
+    messageId: ctx.messageId,
+    agentId,
+    events
+  });
+}
 
 // src/commands/connect/append-message-tool.ts
 function createAppendMessageCustomTools(cfg, messageId) {
@@ -2923,8 +3753,7 @@ function createAppendMessageCustomTools(cfg, messageId) {
 }
 
 // src/commands/connect/ask-question-tool.ts
-import { randomUUID } from "crypto";
-function createAskQuestionTool(options) {
+function createAskQuestionMockTool(options) {
   return {
     description: "Collect structured multiple-choice answers from the user. Use when blocked on a decision that is genuinely the user's to make.",
     inputSchema: {
@@ -2962,61 +3791,6 @@ function createAskQuestionTool(options) {
       },
       required: ["questions"]
     },
-    execute: async (args) => {
-      const record = args;
-      const questions = record.questions;
-      if (!Array.isArray(questions) || questions.length === 0) {
-        return "questions \u4E0D\u80FD\u4E3A\u7A7A";
-      }
-      const api = createApmApiClient(options.cfg);
-      await api.cli.createCoordinatorDispatchQuestions({
-        dispatchId: options.dispatchId,
-        batchId: randomUUID(),
-        title: typeof record.title === "string" ? record.title : void 0,
-        questions
-      });
-      options.onSubmitted?.();
-      return "\u5DF2\u5411\u7528\u6237\u63D0\u4EA4\u95EE\u9898\uFF0C\u8BF7\u7ED3\u675F\u672C\u8F6E run\uFF0C\u7B49\u5F85\u7528\u6237\u5728\u534F\u8C03\u4F1A\u8BDD\u9875\u56DE\u7B54\u540E\u7EE7\u7EED\u3002";
-    }
-  };
-}
-
-// src/commands/connect/ask-question-tool.mock.ts
-function createAskQuestionMockTool(options) {
-  return {
-    description: "Collect structured multiple-choice answers from the user. Use when blocked on a decision that is genuinely the user's to make.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        title: { type: "string" },
-        questions: {
-          type: "array",
-          minItems: 1,
-          items: {
-            type: "object",
-            properties: {
-              id: { type: "string" },
-              prompt: { type: "string" },
-              allow_multiple: { type: "boolean" },
-              options: {
-                type: "array",
-                minItems: 2,
-                items: {
-                  type: "object",
-                  properties: {
-                    id: { type: "string" },
-                    label: { type: "string" }
-                  },
-                  required: ["id", "label"]
-                }
-              }
-            },
-            required: ["id", "prompt", "options"]
-          }
-        }
-      },
-      required: ["questions"]
-    },
     execute: async (args) => {
       const payload = JSON.stringify(args, null, 2);
       console.log(`[apm] AskQuestion mock \u8C03\u7528:
@@ -3041,16 +3815,6 @@ function createCursorCustomTools(cfg, messageId, options) {
     })
   };
 }
-function createCursorDispatchCustomTools(cfg, options) {
-  return {
-    ...createAppendDispatchResponseTools(cfg, options.dispatchId),
-    AskQuestion: createAskQuestionTool({
-      cfg,
-      dispatchId: options.dispatchId,
-      onSubmitted: options.onAskQuestionSubmitted
-    })
-  };
-}
 function withPlanModeToolHint(prompt, mode) {
   if (mode !== "plan") {
     return prompt;
@@ -3137,7 +3901,7 @@ async function runCursorAgent(cfg, ctx, options) {
     throw new Error("\u7F3A\u5C11 apiKey\uFF0C\u65E0\u6CD5\u8C03\u7528 Cursor SDK");
   }
   const workdir = resolveWorkdirPath(ctx.workdir);
-  const customTools = options?.customTools ?? createCursorCustomTools(cfg, ctx.messageId, {
+  const customTools = createCursorCustomTools(cfg, ctx.messageId, {
     onAskQuestion: options?.onAskQuestion
   });
   const prompt = withPlanModeToolHint(ctx.prompt, ctx.mode);
@@ -3265,94 +4029,21 @@ async function runCursorAgent(cfg, ctx, options) {
   }
 }
 
-// src/commands/connect/coordinator-dispatch-handler.ts
-async function handleInboundCoordinatorDispatch(cfg, msg, signal) {
-  const workdir = requireRemoteWorkdir(msg.workdir);
-  assertApmGitignoredInRepo(workdir);
-  await ensureWorkspaceInitialized(workdir);
-  const api = createApmApiClient(cfg);
-  let askQuestionSubmitted = false;
-  try {
-    await api.cli.updateCoordinatorDispatchStatus({
-      id: msg.dispatchId,
-      status: "DISPATCHING"
-    });
-    const result = await runCursorAgent(
-      cfg,
-      {
-        messageId: msg.dispatchId,
-        sessionId: msg.dispatchSessionId,
-        prompt: msg.content,
-        model: msg.model,
-        apiKey: msg.apiKey,
-        workdir: msg.workdir,
-        user: msg.user,
-        mode: msg.mode,
-        resumeAgentId: msg.type === "coordinator_dispatch_resume" ? msg.resumeAgentId : msg.resumeAgentId
-      },
-      {
-        signal,
-        forceSend: true,
-        skipRemoteLogSync: true,
-        customTools: createCursorDispatchCustomTools(cfg, {
-          dispatchId: msg.dispatchId,
-          onAskQuestionSubmitted: () => {
-            askQuestionSubmitted = true;
-          }
-        })
-      }
-    );
-    if (askQuestionSubmitted) {
-      if (result.agentId) {
-        await api.cli.completeCoordinatorDispatch({
-          id: msg.dispatchId,
-          agentId: result.agentId
-        });
-      }
-      console.log(
-        `[apm] \u534F\u8C03\u6D3E\u53D1 ${msg.dispatchId} \u5DF2\u63D0\u4EA4 AskQuestion\uFF0C\u7B49\u5F85\u7528\u6237\u7B54\u9898`
-      );
-      return;
-    }
-    await api.cli.completeCoordinatorDispatch({
-      id: msg.dispatchId,
-      agentId: result.agentId,
-      createPlan: result.createPlan,
-      artifacts: result.artifactDocuments.map((doc) => ({
-        name: doc.path.split("/").pop() ?? doc.path,
-        content: doc.content
-      })),
-      status: "SUCCESS"
-    });
-    console.log(`[apm] \u534F\u8C03\u6D3E\u53D1\u5B8C\u6210 dispatchId=${msg.dispatchId}`);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`[apm] \u534F\u8C03\u6D3E\u53D1\u5931\u8D25 dispatchId=${msg.dispatchId}:`, message);
-    if (!askQuestionSubmitted) {
-      await api.cli.completeCoordinatorDispatch({
-        id: msg.dispatchId,
-        status: "FAILED",
-        error: message
-      });
-    }
-  }
-}
-
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
 import { join as join14 } from "path";
 var CLI_VERSION_FILE = ".cli-version.json";
 function manifestPath(apmDir) {
   return join14(apmDir, CLI_VERSION_FILE);
 }
-function loadManifest3(apmDir) {
-  const path10 = toFsPath(manifestPath(apmDir));
-  if (!existsSync12(path10)) {
+function loadManifest4(apmDir) {
+  const path12 = toFsPath(manifestPath(apmDir));
+  if (!existsSync16(path12)) {
     return null;
   }
   try {
     const parsed = JSON.parse(
-      readFileSync11(path10, "utf8")
+      readFileSync14(path12, "utf8")
     );
     if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
       return parsed;
@@ -3361,9 +4052,9 @@ function loadManifest3(apmDir) {
   }
   return null;
 }
-function saveManifest3(apmDir, cliVersion) {
+function saveManifest4(apmDir, cliVersion) {
   const manifest = { version: 1, cliVersion };
-  writeFileSync11(
+  writeFileSync12(
     toFsPath(manifestPath(apmDir)),
     `${JSON.stringify(manifest, null, 2)}
 `,
@@ -3376,7 +4067,7 @@ function shouldSyncSkillsForCliVersion(workdir, currentVersion) {
   if (cached === currentVersion) {
     return false;
   }
-  const stored = loadManifest3(workspaceApmDir(workdir));
+  const stored = loadManifest4(workspaceApmDir(workdir));
   if (stored?.cliVersion === currentVersion) {
     syncedInSession.set(workdir, currentVersion);
     return false;
@@ -3384,7 +4075,7 @@ function shouldSyncSkillsForCliVersion(workdir, currentVersion) {
   return true;
 }
 function markSkillsSyncedForCliVersion(workdir, cliVersion) {
-  saveManifest3(workspaceApmDir(workdir), cliVersion);
+  saveManifest4(workspaceApmDir(workdir), cliVersion);
   syncedInSession.set(workdir, cliVersion);
 }
 
@@ -3611,7 +4302,7 @@ function reexecConnect(options) {
   if (server) {
     args.push("--server", server);
   }
-  const result = spawnSync2(process.execPath, args, { stdio: "inherit" });
+  const result = spawnSync4(process.execPath, args, { stdio: "inherit" });
   if (result.error) {
     console.error("[apm] \u91CD\u542F connect \u5931\u8D25:", result.error.message);
     process.exit(1);
@@ -3713,27 +4404,6 @@ async function runConnect(options) {
         });
         return;
       }
-      if (validated.data.type === "coordinator_dispatch" || validated.data.type === "coordinator_dispatch_resume") {
-        const msg2 = validated.data;
-        const perDispatchController = new AbortController();
-        const signal2 = AbortSignal.any([
-          shutdownAbort.signal,
-          perDispatchController.signal
-        ]);
-        const task2 = (async () => {
-          await runSlots.acquire();
-          try {
-            await handleInboundCoordinatorDispatch(cfg, msg2, signal2);
-          } finally {
-            runSlots.release();
-          }
-        })();
-        activeTasks.add(task2);
-        void task2.finally(() => {
-          activeTasks.delete(task2);
-        });
-        return;
-      }
       if (validated.data.type !== "message") {
         return;
       }
@@ -3771,199 +4441,120 @@ async function runConnect(options) {
     ws.on("close", (code, reason) => {
       console.log(
         `[apm] \u8FDE\u63A5\u5DF2\u65AD\u5F00 code=${code}${reason ? ` reason=${reason.toString()}` : ""}`
-      );
-      void shutdown();
-    });
-    ws.on("error", (err) => {
-      console.error("[apm] WebSocket \u9519\u8BEF:", err.message);
-      reject(err);
-    });
-    process.on("SIGINT", () => {
-      console.log("[apm] \u6B63\u5728\u5173\u95ED\u2026");
-      void shutdown();
-    });
-    process.on("SIGTERM", () => {
-      void shutdown();
-    });
-  });
-}
-
-// src/commands/create-pr.ts
-async function runCreatePr(options) {
-  const sessionId = options.sessionId.trim();
-  if (!sessionId) {
-    console.error("[apm] sessionId \u4E0D\u80FD\u4E3A\u7A7A");
-    process.exit(1);
-  }
-  const title = options.title.trim();
-  if (!title) {
-    console.error("[apm] \u8BF7\u901A\u8FC7 --title \u6307\u5B9A PR \u6807\u9898");
-    process.exit(1);
-  }
-  const cfg = await ensureLoggedConfig();
-  const api = createApmApiClient(cfg);
-  const workdir = resolveWorkdirPath(options.cwd ?? process.cwd());
-  const pr = await api.cli.createPullRequest({
-    sessionId,
-    workdir,
-    title,
-    content: options.content ?? ""
-  });
-  console.log(`[apm] PR \u5DF2\u5C31\u7EEA #${pr.number} (${pr.state}): ${pr.url}`);
-}
-
-// src/commands/deploy/backend.ts
-import path5 from "node:path";
-
-// src/commands/deploy/internal/apm-config.ts
-import { existsSync as existsSync13, 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 (!existsSync13(p)) {
-    console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
-    process.exit(1);
-  }
-  try {
-    const raw = readFileSync12(p, "utf8");
-    return JSON.parse(raw);
-  } catch (e) {
-    console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
-    process.exit(1);
-  }
-}
-function req(v, field) {
-  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D backendDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
-    process.exit(1);
-  }
-  return v;
-}
-function reqTopLevelName(cfg) {
-  const n = (cfg.name ?? "").trim();
-  if (!n) {
-    console.error(
-      "\u8BF7\u5728 apm.config.json \u9876\u5C42\u914D\u7F6E name\uFF08\u4E0E\u524D\u7AEF\u5236\u54C1\u524D\u7F00\u3001\u540E\u7AEF\u955C\u50CF\u540D\u5171\u7528\uFF09"
-    );
-    process.exit(1);
-  }
-  return n;
-}
-function reqBackendPositiveInt(v, field) {
-  const n = Number(v);
-  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
-    console.error(`apm.config.json \u4E2D backendDeploy.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
-    process.exit(1);
-  }
-  return n;
-}
-function resolveBackendDeployFromApmConfig(cfg) {
-  const b = cfg.backendDeploy ?? {};
-  const protoRaw = req(b.remoteProtocol, "remoteProtocol").trim().toLowerCase();
-  if (protoRaw !== "http" && protoRaw !== "https") {
-    console.error(
-      "apm.config.json \u4E2D backendDeploy.remoteProtocol \u53EA\u80FD\u4E3A http \u6216 https"
-    );
-    process.exit(1);
-  }
-  const remoteProtocol = protoRaw;
-  let mappings = [];
-  const rawPorts = b.containerPortsMappings;
-  if (rawPorts !== void 0 && rawPorts !== null) {
-    if (!Array.isArray(rawPorts)) {
-      console.error(
-        "apm.config.json \u4E2D backendDeploy.containerPortsMappings \u987B\u4E3A\u5B57\u7B26\u4E32\u6570\u7EC4\uFF08\u53EF\u4E3A\u7A7A\uFF0C\u7701\u7565\u5219\u4E0D\u52A0\u7AEF\u53E3\u6620\u5C04\uFF09"
-      );
-      process.exit(1);
-    }
-    mappings = rawPorts.map((x) => String(x).trim()).filter(Boolean);
-  }
-  return {
-    name: reqTopLevelName(cfg),
-    registryHost: req(b.registryHost, "registryHost").trim(),
-    registryNamespace: req(b.registryNamespace, "registryNamespace").trim(),
-    registryUser: req(b.registryUser, "registryUser").trim(),
-    registryPassword: req(b.registryPassword, "registryPassword").trim(),
-    remoteHost: req(b.remoteHost, "remoteHost").trim(),
-    remotePort: reqBackendPositiveInt(b.remotePort, "remotePort"),
-    remoteProtocol,
-    caPath: b.caPath?.trim(),
-    certPath: b.certPath?.trim(),
-    keyPath: b.keyPath?.trim(),
-    envFilePath: typeof b.envFilePath === "string" ? b.envFilePath.trim() : "",
-    containerPortsMappings: mappings,
-    dockerNetwork: b.dockerNetwork?.trim() || void 0
-  };
+      );
+      void shutdown();
+    });
+    ws.on("error", (err) => {
+      console.error("[apm] WebSocket \u9519\u8BEF:", err.message);
+      reject(err);
+    });
+    process.on("SIGINT", () => {
+      console.log("[apm] \u6B63\u5728\u5173\u95ED\u2026");
+      void shutdown();
+    });
+    process.on("SIGTERM", () => {
+      void shutdown();
+    });
+  });
 }
-function reqFe(v, field) {
-  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D frontendDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+
+// src/commands/create-pr.ts
+async function runCreatePr(options) {
+  const sessionId = options.sessionId.trim();
+  if (!sessionId) {
+    console.error("[apm] sessionId \u4E0D\u80FD\u4E3A\u7A7A");
     process.exit(1);
   }
-  return v;
-}
-function resolveFrontendDeployFromApmConfig(cfg) {
-  const f = cfg.frontendDeploy ?? {};
-  const port = Number(f.port);
-  return {
-    endpoint: reqFe(f.endpoint, "endpoint").trim(),
-    port: Number.isFinite(port) && port > 0 ? port : 9e3,
-    useSsl: Boolean(f.useSsl),
-    accessKey: reqFe(f.accessKey, "accessKey").trim(),
-    secretKey: reqFe(f.secretKey, "secretKey").trim(),
-    bucket: reqFe(f.bucket, "bucket").trim()
-  };
-}
-function reqWd(v, field) {
-  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+  const title = options.title.trim();
+  if (!title) {
+    console.error("[apm] \u8BF7\u901A\u8FC7 --title \u6307\u5B9A PR \u6807\u9898");
     process.exit(1);
   }
-  return v;
+  const cfg = await ensureLoggedConfig();
+  const api = createApmApiClient(cfg);
+  const workdir = resolveWorkdirPath(options.cwd ?? process.cwd());
+  const pr = await api.cli.createPullRequest({
+    sessionId,
+    workdir,
+    title,
+    content: options.content ?? ""
+  });
+  console.log(`[apm] PR \u5DF2\u5C31\u7EEA #${pr.number} (${pr.state}): ${pr.url}`);
 }
-function reqWisdomPositiveInt(v, field) {
-  const n = Number(v);
-  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
-    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
-    process.exit(1);
+
+// src/commands/deploy/deploy.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+function runShellCommand3(command, cwd) {
+  console.error(`==> ${command}`);
+  const result = spawnSync5(command, {
+    cwd,
+    stdio: "inherit",
+    shell: true,
+    env: process.env
+  });
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
   }
-  return n;
 }
-function resolveWisdomDeployFromApmConfig(cfg) {
-  const w = cfg.wisdomDeploy ?? {};
-  return {
-    host: reqWd(w.host, "host").trim(),
-    port: reqWisdomPositiveInt(w.port, "port"),
-    username: reqWd(w.username, "username").trim(),
-    password: reqWd(w.password, "password").trim(),
-    remotePath: reqWd(w.remotePath, "remotePath").trim()
-  };
+function registerDeployMainCommand(program) {
+  program.command("deploy").description(
+    "\u7EDF\u4E00\u90E8\u7F72\uFF1A\u533B\u52A1\u5B58\u91CF\u9879\u76EE\u81EA\u52A8\u8BC6\u522B\u524D\u540E\u7AEF\uFF1B\u5176\u4ED6\u9879\u76EE\u6309 deploy.<\u73AF\u5883> \u6267\u884C shell \u547D\u4EE4"
+  ).argument("<env>", "\u90E8\u7F72\u73AF\u5883\u540D\uFF08\u5982 test\u3001online\uFF09").option(
+    "--config <path>",
+    "apm.config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 .apm/apm.config.json\uFF09"
+  ).option("--skip-maven", "\u8DF3\u8FC7 Maven \u6784\u5EFA\uFF08\u4EC5\u533B\u52A1\u540E\u7AEF\uFF09").action(
+    async (env, opts) => {
+      const cwd = process.cwd();
+      const cfg = loadApmConfig({ configPath: opts.config });
+      if (isWisdomLegacyDeploy(cfg)) {
+        await runWisdomAutoDeploy({
+          env,
+          cwd,
+          configPath: opts.config,
+          skipMaven: opts.skipMaven
+        });
+        return;
+      }
+      const deployCommands = cfg.deploy ?? {};
+      const command = deployCommands[env]?.trim();
+      if (!command) {
+        const keys = Object.keys(deployCommands);
+        console.error(
+          keys.length > 0 ? `apm.config.json \u4E2D\u672A\u914D\u7F6E deploy.${env}\uFF0C\u53EF\u7528\u73AF\u5883: ${keys.join(
+            ", "
+          )}` : `apm.config.json \u4E2D\u672A\u914D\u7F6E deploy \u6BB5`
+        );
+        process.exit(1);
+      }
+      runShellCommand3(command, cwd);
+    }
+  );
 }
 
+// src/commands/deploy/backend.ts
+import path8 from "node:path";
+
 // src/commands/deploy/internal/backend-deploy/backend-deploy-workflow.ts
-import path4 from "node:path";
+import path7 from "node:path";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/client.ts
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13 } from "node:fs";
-import path from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "node:fs";
+import path4 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
     console.log("tls filepath not exist");
     return void 0;
   }
-  console.log("tls filepath", path.join(process.cwd(), value));
+  console.log("tls filepath", path4.join(process.cwd(), value));
   const normalized = value.trim();
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync14(normalized)) {
-    return readFileSync13(normalized);
+  if (existsSync17(normalized)) {
+    return readFileSync15(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -4173,8 +4764,8 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync15, readFileSync as readFileSync14, statSync as statSync5 } from "node:fs";
-import path2 from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync16, statSync as statSync6 } from "node:fs";
+import path5 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
   if (t.length >= 2) {
@@ -4189,11 +4780,11 @@ function loadEnvFromFile(envFilePath) {
   if (!envFilePath) {
     return {};
   }
-  const targetPath = path2.resolve(envFilePath);
-  if (!existsSync15(targetPath) || !statSync5(targetPath).isFile()) {
+  const targetPath = path5.resolve(envFilePath);
+  if (!existsSync18(targetPath) || !statSync6(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync14(targetPath, "utf-8");
+  const raw = readFileSync16(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -4364,12 +4955,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync16 } from "node:fs";
-import path3 from "node:path";
+import { existsSync as existsSync19 } from "node:fs";
+import path6 from "node:path";
 function resolveDockerBuildPaths(cwd) {
-  const dockerfilePath = path3.join(cwd, "Dockerfile");
+  const dockerfilePath = path6.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
-  if (!existsSync16(dockerfilePath)) {
+  if (!existsSync19(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");
@@ -4424,7 +5015,7 @@ var BackendDeployWorkflow = class {
       serveraddress
     });
     Logger.success("\u8FDC\u7A0B\u62C9\u53D6\u955C\u50CF\u5B8C\u6210");
-    const envFilePath = path4.resolve(cwd, this.params.envFilePath || ".env");
+    const envFilePath = path7.resolve(cwd, this.params.envFilePath || ".env");
     const envObj = loadEnvFromFile(envFilePath);
     if (this.params.dockerNetwork?.trim()) {
       Logger.info(`\u8FDC\u7A0B\u5BB9\u5668\u5C06\u52A0\u5165 Docker \u7F51\u7EDC\uFF1A${this.params.dockerNetwork.trim()}`);
@@ -4464,7 +5055,7 @@ function registerDeployBackendCommands(program) {
       assertDeployImageTag(tag);
       const cfg = loadApmConfig({ configPath: opts.config });
       const fromApm = resolveBackendDeployFromApmConfig(cfg);
-      const dirAbs = path5.resolve(process.cwd(), opts.dir || "servers/api");
+      const dirAbs = path8.resolve(process.cwd(), opts.dir || "servers/api");
       const params = {
         image: fromApm.name,
         tag,
@@ -4494,18 +5085,18 @@ function registerDeployBackendCommands(program) {
 }
 
 // src/commands/deploy/frontend.ts
-import { copyFile, readdir as readdir2, stat } from "node:fs/promises";
-import path7 from "node:path";
+import { copyFile, readdir as readdir3, stat } from "node:fs/promises";
+import path10 from "node:path";
 
 // src/commands/deploy/internal/minio.ts
-import { statSync as statSync6 } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import path6 from "node:path";
+import { statSync as statSync7 } from "node:fs";
+import { readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
+import path9 from "node:path";
 import * as Minio from "minio";
 var DEFAULT_MAX_FILE_SIZE_MB = 50;
 async function isDirectoryPath(dir) {
   try {
-    const st = statSync6(dir);
+    const st = statSync7(dir);
     return st.isDirectory();
   } catch {
     return false;
@@ -4524,18 +5115,18 @@ function sanitizeRelativePath(rel) {
 async function collectFiles(root) {
   const out = [];
   async function walk(dir, prefix) {
-    const entries = await readdir(dir, { withFileTypes: true });
+    const entries = await readdir2(dir, { withFileTypes: true });
     for (const e of entries) {
       const name = e.name;
       if (name === "." || name === "..") {
         continue;
       }
-      const abs = path6.join(dir, name);
+      const abs = path9.join(dir, name);
       const rel = prefix ? `${prefix}/${name}` : name;
       if (e.isDirectory()) {
         await walk(abs, rel);
       } else if (e.isFile()) {
-        const st = statSync6(abs);
+        const st = statSync7(abs);
         out.push({
           absPath: abs,
           relativePath: rel.replace(/\\/g, "/"),
@@ -4549,7 +5140,7 @@ async function collectFiles(root) {
   return out;
 }
 async function readArtifactFile(absPath) {
-  return readFile(absPath);
+  return readFile2(absPath);
 }
 function toMB(bytes) {
   return Math.round(bytes / (1024 * 1024) * 1e3) / 1e3;
@@ -4573,7 +5164,7 @@ var MIME = {
   ".map": "application/json"
 };
 function detectMimeType(filePath) {
-  const ext = path6.extname(filePath).toLowerCase();
+  const ext = path9.extname(filePath).toLowerCase();
   return MIME[ext] ?? "";
 }
 var MinioClient = class {
@@ -4661,7 +5252,7 @@ function artifactObjectKey(namePrefix, branchSegment, relativePath) {
   return `${base}/${branchSegment}/dist/${rel}`;
 }
 async function ensureArtifactRootIndexHtml(root) {
-  const indexHtmlPath = path7.join(root, "index.html");
+  const indexHtmlPath = path10.join(root, "index.html");
   try {
     const st = await stat(indexHtmlPath);
     if (st.isFile()) {
@@ -4671,14 +5262,14 @@ async function ensureArtifactRootIndexHtml(root) {
   }
   let entries;
   try {
-    entries = await readdir2(root, { withFileTypes: true });
+    entries = await readdir3(root, { withFileTypes: true });
   } catch (e) {
     console.error(`\u65E0\u6CD5\u8BFB\u53D6\u4EA7\u7269\u76EE\u5F55\uFF1A${root}`, e);
     process.exit(1);
   }
   const dirNames = entries.filter((e) => e.isDirectory()).map((e) => String(e.name)).sort();
   for (const name of dirNames) {
-    const candidate = path7.join(root, name, "index.html");
+    const candidate = path10.join(root, name, "index.html");
     try {
       const st = await stat(candidate);
       if (!st.isFile()) {
@@ -4689,7 +5280,7 @@ async function ensureArtifactRootIndexHtml(root) {
     }
     await copyFile(candidate, indexHtmlPath);
     console.error(
-      `\u4EA7\u7269\u534F\u8BAE\uFF1A\u5DF2\u5C06 ${path7.join(name, "index.html")} \u590D\u5236\u4E3A\u6839\u76EE\u5F55 index.html`
+      `\u4EA7\u7269\u534F\u8BAE\uFF1A\u5DF2\u5C06 ${path10.join(name, "index.html")} \u590D\u5236\u4E3A\u6839\u76EE\u5F55 index.html`
     );
     return;
   }
@@ -4725,7 +5316,7 @@ function registerDeployFrontendCommands(program) {
         secretKey: settings.secretKey
       });
       const bucket = settings.bucket;
-      const root = path7.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);
@@ -4794,159 +5385,7 @@ function registerDeployFrontendCommands(program) {
 }
 
 // src/commands/deploy/sftp.ts
-import path9 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 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);
-    if (entry.isDirectory()) {
-      const folder = zipFolder.folder(entry.name);
-      if (folder) {
-        await addDirToZip(fullPath, folder);
-      }
-    } else {
-      const content = await readFile2(fullPath);
-      zipFolder.file(entry.name, content);
-    }
-  }
-}
-async function zipDirectory(distDir, zipPath) {
-  console.error(`\u538B\u7F29\u76EE\u5F55: ${distDir}`);
-  const zip = new JSZip();
-  await addDirToZip(distDir, zip);
-  const content = await zip.generateAsync({
-    type: "nodebuffer",
-    compression: "DEFLATE",
-    compressionOptions: { level: 6 }
-  });
-  await writeFile(zipPath, content);
-  const sizeMb = (content.length / 1024 / 1024).toFixed(2);
-  console.error(`\u5DF2\u751F\u6210: ${zipPath} (${sizeMb} MB)`);
-  return content.length;
-}
-async function ensureRemoteDir(sftp, dir) {
-  const parts = dir.replace(/\\/g, "/").split("/").filter(Boolean);
-  let current = dir.startsWith("/") ? "" : ".";
-  for (const part of parts) {
-    current = current ? `${current}/${part}` : `/${part}`;
-    try {
-      await sftp.mkdir(current, true);
-    } catch {
-    }
-  }
-}
-function execCommand(client, command) {
-  return new Promise((resolve5, reject) => {
-    client.exec(command, (err, stream) => {
-      if (err) return reject(err);
-      let stdout = "";
-      let stderr = "";
-      stream.on("close", (code) => {
-        if (code !== 0) {
-          reject(new Error(`\u8FDC\u7A0B\u547D\u4EE4\u5931\u8D25 (${code}): ${stderr || stdout}`));
-          return;
-        }
-        resolve5(stdout);
-      }).on("data", (data) => {
-        stdout += data.toString();
-      });
-      stream.stderr.on("data", (data) => {
-        stderr += data.toString();
-      });
-    });
-  });
-}
-function shellSingleQuote(value) {
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function buildClearRemoteDirExceptZipCommand(target) {
-  const normalized = target.replace(/\\/g, "/").replace(/\/$/, "");
-  const quotedTarget = shellSingleQuote(normalized);
-  const script = [
-    `T=${quotedTarget}`,
-    "S=$(mktemp -d)",
-    'while IFS= read -r -d "" z; do r="${z#${T}/}"',
-    'mkdir -p "${S}/$(dirname "$r")"',
-    'mv "$z" "${S}/${r}"',
-    'done < <(find "$T" -mindepth 1 -type f -iname "*.zip" -print0)',
-    'rm -rf "${T}"/*',
-    'while IFS= read -r -d "" r; do r="${r#./}"',
-    'mkdir -p "${T}/$(dirname "$r")"',
-    'mv "${S}/${r}" "${T}/${r}"',
-    'done < <(cd "$S" 2>/dev/null && find . -type f -print0)',
-    'rm -rf "$S"'
-  ].join("; ");
-  return `bash -c ${shellSingleQuote(script)}`;
-}
-async function uploadAndMaybeExtract(settings, localZip, extract) {
-  const remoteZipPath = `${settings.remotePath.replace(/\/$/, "")}/dist.zip`;
-  console.error(
-    `\u8FDE\u63A5 ${settings.username}@${settings.host}:${settings.port} ...`
-  );
-  const sftp = new SftpClient();
-  try {
-    await sftp.connect({
-      host: settings.host,
-      port: settings.port,
-      username: settings.username,
-      password: settings.password,
-      readyTimeout: 2e4,
-      tryKeyboard: true
-    });
-    await ensureRemoteDir(sftp, settings.remotePath);
-    await sftp.put(localZip, remoteZipPath);
-    console.error(`  \u2713 ${localZip} -> ${remoteZipPath}`);
-    if (extract) {
-      const target = settings.remotePath.replace(/\/$/, "");
-      const client = sftp.client;
-      const clearCmd = buildClearRemoteDirExceptZipCommand(target);
-      console.error(`\u8FDC\u7A0B\u6E05\u7406\u89E3\u538B\u76EE\u5F55: ${clearCmd}`);
-      await execCommand(client, clearCmd);
-      const unzipCmd = `unzip -o "${remoteZipPath}" -d "${target}"`;
-      console.error(`\u8FDC\u7A0B\u89E3\u538B: ${unzipCmd}`);
-      await execCommand(client, unzipCmd);
-      console.error("\u8FDC\u7A0B\u89E3\u538B\u5B8C\u6210!");
-    }
-    console.error(extract ? "\u90E8\u7F72\u5B8C\u6210!" : "\u4E0A\u4F20\u5B8C\u6210!");
-  } finally {
-    await sftp.end();
-  }
-}
-async function runWisdomSftpDeploy(params) {
-  const zipPath = path8.join(params.localDir, "..", ".deploy-sftp-dist.zip");
-  const resolvedZipPath = path8.resolve(zipPath);
-  let zipSizeBytes = 0;
-  try {
-    zipSizeBytes = await zipDirectory(params.localDir, resolvedZipPath);
-    await uploadAndMaybeExtract(
-      params.settings,
-      resolvedZipPath,
-      params.extract
-    );
-  } finally {
-    try {
-      await unlink(resolvedZipPath);
-      console.error(`\u5DF2\u6E05\u7406\u672C\u5730\u4E34\u65F6\u6587\u4EF6: ${resolvedZipPath}`);
-    } catch {
-    }
-  }
-  return {
-    ok: true,
-    localDir: params.localDir,
-    host: params.settings.host,
-    remotePath: params.settings.remotePath,
-    zipSizeBytes,
-    extracted: params.extract
-  };
-}
-
-// src/commands/deploy/sftp.ts
+import path11 from "node:path";
 function registerDeploySftpCommands(program) {
   program.command("deploy-sftp").description(
     "\u5C06\u6307\u5B9A\u76EE\u5F55\u538B\u7F29\u4E3A zip \u540E\u901A\u8FC7 SFTP \u4E0A\u4F20\u5230\u8FDC\u7A0B\u670D\u52A1\u5668\uFF08\u8FDE\u63A5\u4FE1\u606F\u89C1 apm.config.json wisdomDeploy\uFF09"
@@ -4961,7 +5400,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 = path11.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);
@@ -4982,11 +5421,30 @@ function registerDeploySftpCommands(program) {
   );
 }
 
+// src/commands/deploy/wisdom-backend.ts
+function registerDeployWisdomBackendCommands(program) {
+  program.command("deploy-wisdom-backend").description(
+    "Maven \u6784\u5EFA\u540E\u901A\u8FC7 SFTP \u589E\u91CF\u66F4\u65B0\u8FDC\u7A0B lib \u76EE\u5F55\u5E76\u91CD\u542F Spring Boot \u670D\u52A1\uFF08\u914D\u7F6E\u89C1 apm.config.json \u7684 wisdomDeploy \u4E0E healthCheck\uFF09"
+  ).option(
+    "--config <path>",
+    "apm.config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 .apm/apm.config.json\uFF09"
+  ).option("--skip-maven", "\u8DF3\u8FC7 Maven \u6784\u5EFA\uFF0C\u4EC5\u4E0A\u4F20\u5E76\u91CD\u542F").action(async (opts) => {
+    const cfg = loadApmConfig({ configPath: opts.config });
+    const settings = resolveWisdomBackendDeployFromApmConfig(cfg);
+    await runWisdomBackendDeploy({
+      config: settings,
+      skipMaven: Boolean(opts.skipMaven)
+    });
+  });
+}
+
 // src/commands/deploy/index.ts
 function registerDeployCommands(program) {
+  registerDeployMainCommand(program);
   registerDeployBackendCommands(program);
   registerDeployFrontendCommands(program);
   registerDeploySftpCommands(program);
+  registerDeployWisdomBackendCommands(program);
 }
 
 // src/index.ts
@@ -5007,9 +5465,14 @@ function buildProgram() {
     await runInit(opts.name);
   });
   program.command("update").description(
-    `\u901A\u8FC7 npm \u5168\u5C40\u5B89\u88C5 ${CLI_PACKAGE_NAME}@latest\uFF0C\u5C06 apm \u66F4\u65B0\u5230 registry \u6700\u65B0\u7248`
-  ).action(async () => {
-    await runUpdate();
+    `\u901A\u8FC7 npm \u5168\u5C40\u5B89\u88C5 ${CLI_PACKAGE_NAME}\uFF0C\u9ED8\u8BA4\u66F4\u65B0\u5230\u5F53\u524D\u5927\u7248\u672C\uFF08${parseMajorVersion(
+      readCliVersion()
+    )}.x\uFF09\u6700\u65B0\u7248`
+  ).option(
+    "--major",
+    "\u5141\u8BB8\u8DE8\u5927\u7248\u672C\u66F4\u65B0\u5230 registry \u5168\u5C40 latest\uFF08\u9ED8\u8BA4\u4EC5\u8DDF\u968F\u5F53\u524D\u5927\u7248\u672C\uFF09"
+  ).action(async (opts) => {
+    await runUpdate({ allowMajorUpgrade: opts.major === true });
   });
   program.command("update-skills").description(
     "\u540C\u6B65 .apm/ \u4E0B\u7684\u89C4\u5219\u4E0E\u6280\u80FD\uFF1A\u57FA\u7840\u5185\u5BB9\u6765\u81EA CLI \u6A21\u677F\uFF0C\u8865\u5145\u6280\u80FD\u6765\u81EA\u5E73\u53F0"
@@ -5047,7 +5510,7 @@ function buildProgram() {
     await runUpdateMessageStatus(opts);
   });
   program.command("connect").description(
-    "\u8FDE\u63A5\u5E73\u53F0 WebSocket\uFF08/ws/agent\uFF09\uFF0C\u7EF4\u6301\u5FC3\u8DF3\u5E76\u5904\u7406\u4E0B\u884C message\uFF08TYPING \u2192 Cursor \u2192 SUCCESS/FAILED\uFF09\uFF1B\u542F\u52A8\u524D\u81EA\u52A8 apm update \u5230\u6700\u65B0\u7248"
+    "\u8FDE\u63A5\u5E73\u53F0 WebSocket\uFF08/ws/agent\uFF09\uFF0C\u7EF4\u6301\u5FC3\u8DF3\u5E76\u5904\u7406\u4E0B\u884C message\uFF08TYPING \u2192 Cursor \u2192 SUCCESS/FAILED\uFF09\uFF1B\u542F\u52A8\u524D\u81EA\u52A8 apm update \u5230\u5F53\u524D\u5927\u7248\u672C\u6700\u65B0\u7248"
   ).option("--server <url>", "API \u6839\u5730\u5740\uFF0C\u8986\u76D6 config \u4E2D\u7684 baseUrl").action(async (opts) => {
     await runConnect(opts);
   });