ai-project-manage-cli 6.0.64 → 7.0.2

package/dist/index.js

@@ -11,10 +11,10 @@ var APM_CONFIG_DIR = join(homedir(), ".config", "apm");
 var APM_CONFIG_PATH = join(APM_CONFIG_DIR, "config.json");
 var DEFAULT_BASE_URL = "http://127.0.0.1:3000";
 function resolveClientMachineId(cfg) {
-  return (cfg.clientMachineId ?? cfg.userId ?? "").trim();
+  return (cfg.clientMachineId ?? "").trim();
 }
 function resolveApiKey(cfg) {
-  return (cfg.apiKey ?? cfg.token ?? "").trim();
+  return cfg.apiKey.trim();
 }
 async function tryReadApmConfig() {
   try {
@@ -23,14 +23,17 @@ async function tryReadApmConfig() {
     if (typeof v !== "object" || v === null) {
       return null;
     }
-    const rawCfg = v;
-    if (typeof rawCfg.baseUrl !== "string") {
+    const cfg = v;
+    if (typeof cfg.baseUrl !== "string" || typeof cfg.apiKey !== "string") {
       return null;
     }
-    const apiKey = resolveApiKey(rawCfg);
+    const apiKey = cfg.apiKey.trim();
     if (!apiKey) return null;
-    const cfg = v;
-    const clientMachineId = resolveClientMachineId(cfg);
+    const clientMachineId = resolveClientMachineId({
+      baseUrl: cfg.baseUrl,
+      apiKey,
+      clientMachineId: cfg.clientMachineId
+    });
     return {
       baseUrl: cfg.baseUrl.trim().replace(/\/+$/, ""),
       apiKey,
@@ -86,18 +89,18 @@ import { readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "
 // src/command-utils.ts
 import {
   copyFileSync,
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync2,
   readdirSync,
   statSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename, dirname, extname, join as join2, resolve as resolve2 } from "path";
+import { dirname, join as join2, resolve as resolve2, basename } from "path";
 import { fileURLToPath } from "url";
 
 // src/workdir-path.ts
-import { realpathSync } from "fs";
+import { realpathSync, existsSync } from "fs";
 import { platform } from "os";
 import { resolve } from "path";
 function toFsPath(inputPath) {
@@ -142,6 +145,17 @@ function requireRemoteWorkdir(workdir) {
   }
   return resolveWorkdirPath(trimmed);
 }
+function requireExistingWorkdir(workdir) {
+  const trimmed = typeof workdir === "string" ? workdir.trim() : "";
+  if (!trimmed) {
+    throw new Error("[apm] \u5DE5\u4F5C\u76EE\u5F55 workdir \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const resolved = resolveWorkdirPath(trimmed);
+  if (!existsSync(toFsPath(resolved))) {
+    throw new Error(`[apm] \u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728: ${resolved}`);
+  }
+  return resolved;
+}
 
 // src/command-utils.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
@@ -152,7 +166,7 @@ function workspaceApmDir(cwd = resolveWorkdirPath()) {
 function isWorkspaceApmInitialized(workdir) {
   const apmDir = workspaceApmDir(workdir);
   const fsApmDir = toFsPath(apmDir);
-  if (!existsSync(fsApmDir)) {
+  if (!existsSync2(fsApmDir)) {
     return false;
   }
   const st = statSync(fsApmDir);
@@ -163,6 +177,20 @@ function isWorkspaceApmInitialized(workdir) {
   }
   return readdirSync(fsApmDir).length > 0;
 }
+function assertWorkspaceApmDirExists(workdir) {
+  if (!isWorkspaceApmInitialized(workdir)) {
+    const apmDir = workspaceApmDir(workdir);
+    const fsApmDir = toFsPath(apmDir);
+    if (!existsSync2(fsApmDir)) {
+      throw new Error(
+        `\u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u4E0B\u672A\u68C0\u6D4B\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5728\u8BE5\u4ED3\u5E93\u6839\u76EE\u5F55\u6267\u884C apm init \u5B8C\u6210\u63A5\u5165\u3002`
+      );
+    }
+    throw new Error(
+      `\u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u4E0B .apm \u76EE\u5F55\u4E3A\u7A7A\uFF0C\u8BF7\u5728\u8BE5\u4ED3\u5E93\u6839\u76EE\u5F55\u6267\u884C apm init \u5B8C\u6210\u63A5\u5165\u3002`
+    );
+  }
+}
 var APM_GITIGNORE_PATTERNS = [
   /^\.apm\/?$/,
   /^\.apm\/\*\*$/,
@@ -187,7 +215,7 @@ var APM_GITIGNORE_LINE = "**/.apm/**";
 function ensureApmGitignoredInRepo(workdir) {
   const gitignorePath = join2(workdir, ".gitignore");
   const fsGitignorePath = toFsPath(gitignorePath);
-  if (!existsSync(fsGitignorePath)) {
+  if (!existsSync2(fsGitignorePath)) {
     writeFileSync2(fsGitignorePath, `${APM_GITIGNORE_LINE}
 `, "utf8");
     return true;
@@ -205,63 +233,6 @@ function ensureApmGitignoredInRepo(workdir) {
   );
   return true;
 }
-function assertApmGitignoredInRepo(workdir) {
-  const gitignorePath = join2(workdir, ".gitignore");
-  const fsGitignorePath = toFsPath(gitignorePath);
-  if (!existsSync(fsGitignorePath)) {
-    throw new Error(
-      `\u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u7F3A\u5C11 .gitignore \u6587\u4EF6\uFF0C\u8BF7\u6DFB\u52A0\u5BF9 .apm \u7684\u5FFD\u7565\u89C4\u5219\uFF08\u4F8B\u5982 **/.apm/**\uFF09\uFF0C\u907F\u514D\u672C\u5730\u4F1A\u8BDD\u4E0E\u90E8\u7F72\u51ED\u636E\u88AB\u63D0\u4EA4\u3002`
-    );
-  }
-  const content = readFileSync2(fsGitignorePath, "utf8");
-  if (!content.split(/\r?\n/).some(gitignoreIgnoresApm)) {
-    throw new Error(
-      `\u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u7684 .gitignore \u672A\u5FFD\u7565 .apm\uFF0C\u8BF7\u6DFB\u52A0 **/.apm/** \u6216 .apm/\uFF0C\u907F\u514D\u672C\u5730\u4F1A\u8BDD\u4E0E\u90E8\u7F72\u51ED\u636E\u88AB\u63D0\u4EA4\u3002`
-    );
-  }
-}
-var SESSIONS_SUBDIR = "sessions";
-var SESSION_DOCS_SUBDIR = "docs";
-var SESSION_ATTACHMENTS_SUBDIR = "attachments";
-function sessionDir(sessionId, apmRoot) {
-  return join2(apmRoot ?? workspaceApmDir(), SESSIONS_SUBDIR, sessionId);
-}
-function sessionDocsDir(sessionId, apmRoot) {
-  return join2(sessionDir(sessionId, apmRoot), SESSION_DOCS_SUBDIR);
-}
-function sessionRulePath(sessionId, apmRoot) {
-  return join2(sessionDir(sessionId, apmRoot), "RULE.md");
-}
-function sessionTaskPath(sessionId, apmRoot) {
-  return join2(sessionDir(sessionId, apmRoot), "TASK.md");
-}
-function sessionTodoPath(sessionId, apmRoot) {
-  return join2(sessionDir(sessionId, apmRoot), "TODO.md");
-}
-function sessionYamlPath(sessionId, apmRoot) {
-  return join2(sessionDir(sessionId, apmRoot), "session.yaml");
-}
-function sessionMessagesXmlPath(sessionId, apmRoot) {
-  return join2(sessionDir(sessionId, apmRoot), "messages.xml");
-}
-function documentLocalFileName(platformName) {
-  const trimmed = platformName.trim();
-  if (!trimmed) return "document.md";
-  if (extname(trimmed).toLowerCase() === ".md") return trimmed;
-  return `${trimmed}.md`;
-}
-function documentPlatformName(filePath) {
-  const base = basename(filePath.trim().replace(/\\/g, "/"));
-  if (base.toLowerCase().endsWith(".md")) {
-    return base.slice(0, -3);
-  }
-  return base;
-}
-function resolveSessionDocumentPath(sessionId, documentName, apmRoot) {
-  const base = basename(documentName.trim().replace(/\\/g, "/"));
-  const fileName = documentLocalFileName(base);
-  return join2(sessionDocsDir(sessionId, apmRoot), fileName);
-}
 async function ensureLoggedConfig() {
   const cfg = await ensureApmConfig();
   if (!resolveApiKey(cfg)) {
@@ -278,7 +249,7 @@ async function ensureDirExists(dir) {
 async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
   const dir = workspaceApmDir(cwd);
   const fsDir = toFsPath(dir);
-  if (!existsSync(fsDir)) {
+  if (!existsSync2(fsDir)) {
     mkdirSync2(fsDir, { recursive: true });
     return;
   }
@@ -293,7 +264,7 @@ async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
   }
 }
 var WORKSPACE_TEMPLATE_SUBDIRS = [
-  "sessions",
+  "project",
   "skills",
   "rules",
   "deploy"
@@ -323,17 +294,17 @@ function assertTemplateCopiedToApm(apmDir, workdir) {
     "apm.config.json",
     "rules",
     "skills",
-    "sessions"
+    "project"
   ];
   for (const item of required) {
     const path10 = join2(apmDir, item);
-    if (!existsSync(toFsPath(path10))) {
+    if (!existsSync2(toFsPath(path10))) {
       throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path10}`);
     }
   }
   const leakedRules = join2(workdir, "rules");
   const apmRules = join2(apmDir, "rules");
-  if (existsSync(toFsPath(leakedRules)) && !existsSync(toFsPath(join2(apmRules, "reply.md")))) {
+  if (existsSync2(toFsPath(leakedRules)) && !existsSync2(toFsPath(join2(apmRules, "reply.md")))) {
     throw new Error(
       `[apm] \u6A21\u677F\u88AB\u590D\u5236\u5230\u9519\u8BEF\u4F4D\u7F6E: ${leakedRules}\uFF08\u5E94\u5728 ${apmRules}\uFF09`
     );
@@ -343,7 +314,7 @@ async function copyTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
   const resolvedTarget = resolve2(targetDir);
   const templateDir = resolve2(CLI_TEMPLATE_DIR);
   const fsTemplateDir = toFsPath(templateDir);
-  if (!existsSync(fsTemplateDir)) {
+  if (!existsSync2(fsTemplateDir)) {
     throw new Error(`[apm] \u672A\u627E\u5230 CLI \u6A21\u677F\u76EE\u5F55: ${templateDir}`);
   }
   const dirStat = statSync(fsTemplateDir);
@@ -365,6 +336,40 @@ async function copyTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
   }
   assertTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
 }
+var TASKS_SUBDIR = "tasks";
+var TASK_DOCS_SUBDIR = "docs";
+function taskDir(taskId, apmRoot, workdir) {
+  return join2(
+    apmRoot ?? workspaceApmDir(workdir ?? resolveWorkdirPath()),
+    TASKS_SUBDIR,
+    taskId
+  );
+}
+function taskDocsDir(taskId, apmRoot, workdir) {
+  return join2(taskDir(taskId, apmRoot, workdir), TASK_DOCS_SUBDIR);
+}
+function taskRulePath(taskId, apmRoot, workdir) {
+  return join2(taskDir(taskId, apmRoot, workdir), "RULE.md");
+}
+function taskTaskPath(taskId, apmRoot, workdir) {
+  return join2(taskDir(taskId, apmRoot, workdir), "TASK.md");
+}
+function taskYamlPath(taskId, apmRoot, workdir) {
+  return join2(taskDir(taskId, apmRoot, workdir), "task.yaml");
+}
+function documentLocalFileName(platformName) {
+  const trimmed = platformName.trim();
+  if (!trimmed) return "document.md";
+  if (trimmed.toLowerCase().endsWith(".md")) return trimmed;
+  return `${trimmed}.md`;
+}
+function documentPlatformName(filePath) {
+  const base = basename(filePath.trim().replace(/\\/g, "/"));
+  if (base.toLowerCase().endsWith(".md")) {
+    return base.slice(0, -3);
+  }
+  return base;
+}
 
 // src/deployment-config-sync.ts
 import { join as join3 } from "path";
@@ -377,61 +382,9 @@ import { createApiClient } from "listpage-http";
 import { defineEndpoint } from "listpage-http";
 var requestConfig = {
   cli: {
-    me: defineEndpoint(
-      {
-        method: "GET",
-        path: "/cli/me"
-      }
-    ),
-    sessionDetail: defineEndpoint({
-      method: "GET",
-      path: "/cli/sessions/detail"
-    }),
-    sessionMembers: defineEndpoint({
-      method: "GET",
-      path: "/cli/sessions/members"
-    }),
-    listSessionMessages: defineEndpoint({
-      method: "GET",
-      path: "/cli/messages"
-    }),
-    listDocuments: defineEndpoint({
-      method: "GET",
-      path: "/cli/documents"
-    }),
-    listAttachments: defineEndpoint(
-      {
-        method: "GET",
-        path: "/cli/attachments"
-      }
-    ),
-    upsertDocument: defineEndpoint({
-      method: "PUT",
-      path: "/cli/documents/upsert"
-    }),
-    appendMessageContent: defineEndpoint({
-      method: "PUT",
-      path: "/cli/messages/content"
-    }),
-    setMessageError: defineEndpoint({
-      method: "PUT",
-      path: "/cli/messages/error"
-    }),
-    upsertCursorMessageLog: defineEndpoint({
-      method: "PUT",
-      path: "/cli/cursor-message-logs"
-    }),
-    updateMessageStatus: defineEndpoint({
-      method: "PUT",
-      path: "/cli/messages/status"
-    }),
-    branchBaseline: defineEndpoint({
-      method: "GET",
-      path: "/cli/tasks/branch-baseline"
-    }),
-    listSessionsForBranchCleanup: defineEndpoint({
+    me: defineEndpoint({
       method: "GET",
-      path: "/cli/sessions/branch-cleanup"
+      path: "/cli/me"
     }),
     workspaceBaseline: defineEndpoint({
       method: "GET",
@@ -453,10 +406,6 @@ var requestConfig = {
       method: "GET",
       path: "/cli/rules"
     }),
-    createPullRequest: defineEndpoint({
-      method: "POST",
-      path: "/cli/pull-requests"
-    }),
     getRepositoryProjectDocumentManifest: defineEndpoint({
       method: "GET",
       path: "/cli/repository-project-documents/manifest"
@@ -473,33 +422,47 @@ 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({
+    syncTaskDeploymentLog: defineEndpoint(
+      {
+        method: "PUT",
+        path: "/cli/task-deployments/log"
+      }
+    ),
+    completeTaskDeployment: defineEndpoint({
       method: "PUT",
-      path: "/cli/coordinator-deployments/log"
+      path: "/cli/task-deployments/complete"
     }),
-    completeCoordinatorDeployment: defineEndpoint({
-      method: "PUT",
-      path: "/cli/coordinator-deployments/complete"
+    listPendingMailboxMessages: defineEndpoint({
+      method: "GET",
+      path: "/cli/mailbox-messages/pending"
+    }),
+    getMailboxMessageDetail: defineEndpoint({
+      method: "GET",
+      path: "/cli/mailbox-messages/detail"
+    }),
+    listDocuments: defineEndpoint({
+      method: "GET",
+      path: "/cli/documents"
     }),
-    updateCoordinatorDispatchStatus: defineEndpoint({
+    upsertDocument: defineEndpoint({
       method: "PUT",
-      path: "/cli/coordinator-dispatches/status"
+      path: "/cli/documents/upsert"
     }),
-    appendCoordinatorDispatchResponse: defineEndpoint({
+    claimMailboxMessage: defineEndpoint({
       method: "PUT",
-      path: "/cli/coordinator-dispatches/append-response"
+      path: "/cli/mailbox-messages/claim"
     }),
-    completeCoordinatorDispatch: defineEndpoint({
+    completeMailboxMessage: defineEndpoint({
       method: "PUT",
-      path: "/cli/coordinator-dispatches/complete"
+      path: "/cli/mailbox-messages/complete"
     }),
-    createCoordinatorDispatchQuestions: defineEndpoint({
-      method: "POST",
-      path: "/cli/coordinator-dispatches/questions"
+    upsertCursorLog: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-logs"
     })
   }
 };
@@ -535,7 +498,7 @@ async function tryReadGitOriginUrl(cwd) {
 
 // src/deployment-config-sync.ts
 var TEMPLATE_HINT = "\u4FDD\u7559\u6A21\u677F .apm/apm.config.json \u4E0E .apm/deploy/README.md";
-var SYNC_HINT = "\u767B\u8BB0\u5DE5\u4F5C\u7A7A\u95F4\u8DEF\u5F84\u3001\u7ED1\u5B9A\u4ED3\u5E93\u540E\uFF0C\u53EF\u6267\u884C: apm sync-deploy-config";
+var SYNC_HINT = "\u767B\u8BB0\u5DE5\u4F5C\u7A7A\u95F4\u8DEF\u5F84\u3001\u7ED1\u5B9A\u4ED3\u5E93\u540E\uFF0C\u91CD\u65B0 apm init \u53EF\u540C\u6B65\u90E8\u7F72\u914D\u7F6E";
 async function resolveRepositoryIdForSync(api, workdirPath) {
   const baseline = await api.cli.workspaceBaseline({ workdirPath });
   if (baseline.repositoryId) {
@@ -559,7 +522,7 @@ async function syncRemoteDeploymentConfig(workdirPath, apmDir) {
   if (!cfg || !resolveApiKey(cfg)) {
     console.log(
       `[apm] \u672A\u68C0\u6D4B\u5230\u767B\u5F55\u4FE1\u606F\uFF0C\u8DF3\u8FC7\u5E73\u53F0\u90E8\u7F72\u914D\u7F6E\u540C\u6B65\uFF08${TEMPLATE_HINT}\uFF09\u3002
-[apm] \u8BF7\u5148\u6267\u884C apm login\uFF0C\u518D\u6267\u884C apm sync-deploy-config \u62C9\u53D6\u6700\u65B0\u914D\u7F6E\u3002`
+[apm] \u8BF7\u5148\u6267\u884C apm login\uFF0C\u518D\u91CD\u65B0 apm init \u62C9\u53D6\u6700\u65B0\u914D\u7F6E\u3002`
     );
     return { synced: false, repositoryId: null };
   }
@@ -580,7 +543,7 @@ ${diagnostic ?? ""}
   if (!config) {
     console.log(
       `[apm] \u672A\u627E\u5230\u5173\u8054\u4ED3\u5E93\u7684\u90E8\u7F72\u914D\u7F6E\uFF08${TEMPLATE_HINT}\uFF0CrepositoryId\uFF1A${repositoryId}\uFF09\u3002
-[apm] \u8BF7\u5728\u5E73\u53F0\u300C\u90E8\u7F72\u914D\u7F6E\u300D\u4E2D\u521B\u5EFA\u914D\u7F6E\u5E76\u5173\u8054\u8BE5\u4ED3\u5E93\uFF0C\u7136\u540E\u6267\u884C: apm sync-deploy-config`
+[apm] \u8BF7\u5728\u5E73\u53F0\u300C\u90E8\u7F72\u914D\u7F6E\u300D\u4E2D\u521B\u5EFA\u914D\u7F6E\u5E76\u5173\u8054\u8BE5\u4ED3\u5E93\uFF0C\u7136\u540E\u91CD\u65B0 apm init \u540C\u6B65\u3002`
     );
     return { synced: false, repositoryId };
   }
@@ -611,13 +574,12 @@ ${diagnostic ?? ""}
 
 // src/repository-project-documents-sync.ts
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   readdirSync as readdirSync2,
   readFileSync as readFileSync3,
   rmSync,
   writeFileSync as writeFileSync4
 } from "fs";
-import { createHash } from "crypto";
 import { dirname as dirname2, join as join4, relative, sep } from "path";
 var MANIFEST_FILE = "manifest.json";
 function projectDocumentsDir(apmRoot) {
@@ -638,45 +600,19 @@ function normalizeLocalDocumentPath(path10) {
   }
   return segments.join("/");
 }
-function hashLocalFileContent(content) {
-  return createHash("sha256").update(content, "utf8").digest("hex");
-}
 function readLocalManifest(apmRoot) {
-  const manifestPath2 = join4(projectDocumentsDir(apmRoot), MANIFEST_FILE);
-  if (!existsSync2(manifestPath2)) {
+  const manifestPath = join4(projectDocumentsDir(apmRoot), MANIFEST_FILE);
+  if (!existsSync3(manifestPath)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync3(manifestPath2, "utf8")
+      readFileSync3(manifestPath, "utf8")
     );
   } catch {
     return null;
   }
 }
-function listLocalDocumentPaths(apmRoot) {
-  const root = projectDocumentsDir(apmRoot);
-  if (!existsSync2(root)) {
-    return [];
-  }
-  const paths = [];
-  const walk = (dir) => {
-    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-      const abs = join4(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(abs);
-        continue;
-      }
-      if (entry.isFile() && entry.name === MANIFEST_FILE) {
-        continue;
-      }
-      const rel = relative(root, abs).split(sep).join("/");
-      paths.push(rel);
-    }
-  };
-  walk(root);
-  return paths.sort();
-}
 function diffManifestPaths(remote, local) {
   const remoteMap = new Map(
     (remote?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
@@ -755,7 +691,7 @@ ${diagnostic ?? ""}`
   let deleted = 0;
   for (const path10 of deleteLocal) {
     const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path10));
-    if (existsSync2(absPath)) {
+    if (existsSync3(absPath)) {
       rmSync(absPath, { force: true });
       deleted += 1;
     }
@@ -776,50 +712,6 @@ ${diagnostic ?? ""}`
     deleted
   };
 }
-async function syncRepositoryProjectDocumentsPush(cfg, workdirPath, apmRoot) {
-  const api = createApmApiClient(cfg);
-  const { repositoryId } = await resolveRepositoryIdForSync(api, workdirPath);
-  if (!repositoryId) {
-    return 0;
-  }
-  const targetApmDir = apmRoot ?? workspaceApmDir(workdirPath);
-  const localPaths = listLocalDocumentPaths(targetApmDir);
-  if (localPaths.length === 0) {
-    console.log("[apm] \u4ED3\u5E93\u9879\u76EE\u6587\u6863\u65E0\u672C\u5730\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u63A8\u9001");
-    return 0;
-  }
-  const remoteManifest = (await api.cli.getRepositoryProjectDocumentManifest({ repositoryId })).manifest ?? null;
-  const remoteHashByPath = new Map(
-    (remoteManifest?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
-  );
-  const remoteDescriptionByPath = new Map(
-    (remoteManifest?.documents ?? []).map((doc) => [
-      doc.path,
-      doc.description
-    ])
-  );
-  let synced = 0;
-  for (const path10 of localPaths) {
-    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path10));
-    const content = readFileSync3(absPath, "utf8");
-    const contentHash = hashLocalFileContent(content);
-    if (remoteHashByPath.get(path10) === contentHash) {
-      continue;
-    }
-    await api.cli.upsertRepositoryProjectDocument({
-      repositoryId,
-      path: path10,
-      content,
-      description: remoteDescriptionByPath.get(path10) ?? void 0
-    });
-    synced += 1;
-    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path10}`);
-  }
-  if (synced === 0) {
-    console.log("[apm] \u4ED3\u5E93\u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
-  }
-  return synced;
-}
 
 // src/git-utils.ts
 import { execFile as execFile2 } from "child_process";
@@ -929,14 +821,13 @@ async function runInit(name) {
   console.log(`[apm] \u5DE5\u4F5C\u76EE\u5F55\u8DEF\u5F84\uFF1A${workdir}`);
   if (syncResult && !syncResult.synced) {
     console.log(
-      "[apm] \u5F53\u524D .apm/apm.config.json \u4E0E .apm/deploy/README.md \u4E3A\u6A21\u677F\u9ED8\u8BA4\u503C\uFF1B\u5B8C\u6210\u5E73\u53F0\u767B\u8BB0\u540E\u6267\u884C apm sync-deploy-config"
+      "[apm] \u5F53\u524D .apm/apm.config.json \u4E0E .apm/deploy/README.md \u4E3A\u6A21\u677F\u9ED8\u8BA4\u503C\uFF1B\u5B8C\u6210\u5E73\u53F0\u767B\u8BB0\u540E\u91CD\u65B0 apm init \u53EF\u540C\u6B65"
     );
   }
   console.log("[apm] \u8BF7\u5728\u5E73\u53F0\u300C\u63A5\u5165\u7BA1\u7406 \u2192 \u5DE5\u4F5C\u7A7A\u95F4\u300D\u767B\u8BB0\u4E0A\u8FF0\u76EE\u5F55\u8DEF\u5F84");
 }
 
 // src/commands/login.ts
-import { existsSync as existsSync3 } from "fs";
 import { ApiError } from "listpage-http";
 async function runLogin(opts) {
   const baseUrl = (opts.server?.trim() || process.env.AI_PM_SERVER?.trim() || DEFAULT_BASE_URL).replace(/\/+$/, "");
@@ -989,500 +880,106 @@ async function runLogin(opts) {
       2
     )
   );
-  const workdir = resolveWorkdirPath();
-  const apmDir = workspaceApmDir(workdir);
-  if (existsSync3(apmDir)) {
-    await syncRemoteDeploymentConfig(workdir, apmDir);
-  }
 }
 
-// src/commands/branch.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile3);
-var SESSION_BRANCH_PREFIX = "feat/session-";
-function branchNameForSession(sessionId) {
-  const id = sessionId.trim();
-  if (!id) {
-    throw new Error("[apm] \u4F1A\u8BDD ID \u4E0D\u80FD\u4E3A\u7A7A");
-  }
-  if (/[\s/\\]/.test(id)) {
-    throw new Error(
-      "[apm] \u4F1A\u8BDD ID \u4E0D\u80FD\u5305\u542B\u7A7A\u767D\u6216\u8DEF\u5F84\u5206\u9694\u7B26\uFF0C\u8BF7\u4F7F\u7528\u5B57\u6BCD\u3001\u6570\u5B57\u3001._- \u7B49"
-    );
-  }
-  return `${SESSION_BRANCH_PREFIX}${id}`;
-}
-function sessionIdFromBranchName(branch) {
-  const name = branch.trim().replace(/^origin\//, "");
-  if (!name.startsWith(SESSION_BRANCH_PREFIX)) {
-    return null;
-  }
-  const sessionId = name.slice(SESSION_BRANCH_PREFIX.length).trim();
-  return sessionId || null;
-}
-async function execGit2(cwd, args, quiet) {
+// src/commands/update.ts
+import { spawnSync } from "child_process";
+
+// src/version.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var CLI_PACKAGE_NAME = "ai-project-manage-cli";
+function readCliVersion() {
   try {
-    const { stdout, stderr } = await execFileAsync3("git", args, {
-      cwd,
-      encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024
-    });
-    if (!quiet && stderr.trim()) {
-      process.stderr.write(stderr);
-    }
-    return stdout;
-  } catch (err) {
-    const e = err;
-    const detail = (e.stderr ?? e.message ?? String(err)).trim();
-    throw new Error(
-      `[apm] git ${args.join(" ")} \u5931\u8D25${detail ? `: ${detail}` : ""}`
-    );
+    const dir = dirname3(fileURLToPath2(import.meta.url));
+    const pkgPath = join6(dir, "..", "package.json");
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
   }
 }
-async function ensureGitRepo(cwd) {
-  await execGit2(cwd, ["rev-parse", "--git-dir"], true);
-}
-async function getCurrentBranch(cwd) {
-  const name = (await execGit2(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], true)).trim();
-  return name;
-}
-async function isWorkingTreeDirty(cwd) {
-  const out = await execGit2(cwd, ["status", "--porcelain"], true);
-  return out.trim().length > 0;
+
+// src/commands/update.ts
+var useNpmShell = process.platform === "win32";
+function runNpm(args, options = {}) {
+  return spawnSync(useNpmShell ? "npm.cmd" : "npm", args, {
+    ...options,
+    shell: useNpmShell
+  });
 }
-async function remoteHeadBranchExists(cwd, branch) {
-  const out = await execGit2(
-    cwd,
-    ["ls-remote", "--heads", "origin", branch],
-    true
-  );
-  return out.trim().length > 0;
+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 localBranchExists(cwd, branch) {
+async function fetchLatestPublishedVersion() {
+  const url = `${registryBaseUrl()}/${CLI_PACKAGE_NAME}/latest`;
   try {
-    await execGit2(
-      cwd,
-      ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
-      true
-    );
-    return true;
+    const res = await fetch(url);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version?.trim() || null;
   } catch {
-    return false;
+    return null;
   }
 }
-async function commitWorkingTreeIfDirty(cwd, message) {
-  await ensureGitRepo(cwd);
-  if (!await isWorkingTreeDirty(cwd)) {
-    return false;
-  }
-  const commitMessage = message?.trim() || `chore(apm): \u540C\u6B65\u5DE5\u4F5C\u533A (${await getCurrentBranch(cwd)})`;
-  await execGit2(cwd, ["add", "-A"]);
-  await execGit2(cwd, ["commit", "-m", commitMessage]);
-  console.log(`[apm] \u5DF2\u63D0\u4EA4\u5DE5\u4F5C\u533A\u53D8\u66F4: ${commitMessage}`);
-  return true;
+function npmAvailable() {
+  const r = runNpm(["--version"], { encoding: "utf8" });
+  return !r.error && r.status === 0;
 }
-async function ensureFeatureBranch(branch, baselineBranch, options) {
-  const cwd = options.cwd ?? process.cwd();
-  const commitMessage = options.message?.trim() || `chore(apm): \u540C\u6B65\u5DE5\u4F5C\u533A (${branch})`;
-  await ensureGitRepo(cwd);
-  if (!await remoteHeadBranchExists(cwd, baselineBranch)) {
-    throw new Error(
-      `[apm] \u8FDC\u7A0B\u4E0D\u5B58\u5728\u57FA\u7EBF\u5206\u652F ${baselineBranch}\uFF0C\u8BF7\u786E\u8BA4\u4ED3\u5E93\u9ED8\u8BA4\u5206\u652F\u5DF2\u63A8\u9001\u5230 origin`
-    );
-  }
-  const current = await getCurrentBranch(cwd);
-  const dirty = await isWorkingTreeDirty(cwd);
-  if (dirty) {
-    if (current === branch) {
-      await commitWorkingTreeIfDirty(cwd, commitMessage);
-    } else {
-      await execGit2(cwd, [
-        "stash",
-        "push",
-        "-u",
-        "-m",
-        `apm: switch to ${branch}`
-      ]);
-    }
-  }
-  const onTargetBranch = await getCurrentBranch(cwd) === branch;
-  if (onTargetBranch) {
-    await execGit2(cwd, ["fetch", "origin", baselineBranch]);
-    await execGit2(cwd, ["merge", `origin/${baselineBranch}`, "--no-edit"]);
-  } else {
-    const remoteExists = await remoteHeadBranchExists(cwd, branch);
-    if (remoteExists) {
-      await execGit2(cwd, ["fetch", "origin", branch]);
-      await execGit2(cwd, ["checkout", "-B", branch, `origin/${branch}`]);
-    } else if (await localBranchExists(cwd, branch)) {
-      if (await getCurrentBranch(cwd) !== branch) {
-        await execGit2(cwd, ["checkout", branch]);
-      }
-      console.log(`[apm] \u5206\u652F ${branch} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u521B\u5EFA`);
-    } else {
-      await execGit2(cwd, ["fetch", "origin", baselineBranch]);
-      try {
-        await execGit2(cwd, [
-          "checkout",
-          "-b",
-          branch,
-          `origin/${baselineBranch}`
-        ]);
-        await execGit2(cwd, ["push", "-u", "origin", branch]);
-      } catch (err) {
-        if (await localBranchExists(cwd, branch)) {
-          if (await getCurrentBranch(cwd) !== branch) {
-            await execGit2(cwd, ["checkout", branch]);
-          }
-          console.log(`[apm] \u5206\u652F ${branch} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u521B\u5EFA`);
-        } else {
-          throw err;
-        }
-      }
-    }
+async function runUpdate() {
+  const current = readCliVersion();
+  const latest = await fetchLatestPublishedVersion();
+  if (latest && current === latest) {
+    console.log(`[apm] \u5DF2\u662F\u6700\u65B0\u7248\u672C ${current}`);
+    return { didUpdate: false };
   }
-  console.log(`[apm] \u5DF2\u5C31\u7EEA\u5206\u652F ${branch}`);
-  return branch;
-}
-async function runBranch(sessionId, options = {}) {
-  const trimmedSessionId = sessionId.trim();
-  if (!trimmedSessionId) {
-    console.error("[apm] sessionId \u4E0D\u80FD\u4E3A\u7A7A");
+  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`
+    );
     process.exit(1);
   }
-  const cfg = await ensureLoggedConfig();
-  const api = createApmApiClient(cfg);
-  const cwd = options.cwd ?? process.cwd();
-  const workdirPath = resolveWorkdirPath(cwd);
-  const baseline = await api.cli.branchBaseline({
-    sessionId: trimmedSessionId,
-    workdirPath
+  const targetLabel = latest ?? "latest";
+  console.error(
+    `[apm] \u5F53\u524D\u7248\u672C ${current}\uFF0C\u6B63\u5728\u5B89\u88C5 ${CLI_PACKAGE_NAME}@${targetLabel} \u2026`
+  );
+  const install = runNpm(["install", "-g", `${CLI_PACKAGE_NAME}@latest`], {
+    stdio: "inherit"
   });
-  if (!baseline.repositoryId) {
-    const detail = baseline.diagnostic?.message ?? `\u672A\u5728\u5E73\u53F0\u627E\u5230\u4E0E\u5F53\u524D\u76EE\u5F55\u5339\u914D\u7684\u5DE5\u4F5C\u76EE\u5F55\u767B\u8BB0\uFF1A${workdirPath}\uFF08\u89C4\u8303\u5316\uFF1A${baseline.workdirPath}\uFF09
-\u8BF7\u5148\u5728\u5E73\u53F0\u767B\u8BB0\u8BE5\u8DEF\u5F84\u5BF9\u5E94\u7684\u5DE5\u4F5C\u76EE\u5F55\u4E0E\u4ED3\u5E93\u3002`;
-    throw new Error(`[apm] ${detail}`);
+  if (install.error) {
+    console.error("[apm] \u66F4\u65B0\u5931\u8D25:", install.error.message);
+    process.exit(1);
+  }
+  if (install.status !== 0) {
+    process.exit(install.status ?? 1);
   }
-  const baselineBranch = (baseline.defaultBranch ?? "").trim();
-  if (!baselineBranch) {
-    throw new Error("[apm] \u5E73\u53F0\u8FD4\u56DE\u7684\u57FA\u7EBF\u5206\u652F\u540D\u4E3A\u7A7A");
+  const after = readCliVersion();
+  if (latest && after === latest) {
+    console.log(`[apm] \u5DF2\u66F4\u65B0\u5230 ${after}`);
+  } else {
+    console.log(
+      `[apm] \u66F4\u65B0\u5B8C\u6210\u3002\u82E5\u7248\u672C\u53F7\u672A\u53D8\u5316\uFF0C\u8BF7\u5728\u65B0\u7EC8\u7AEF\u6267\u884C apm -V \u786E\u8BA4\uFF08\u5168\u5C40\u5B89\u88C5\u8DEF\u5F84\u53EF\u80FD\u672A\u5237\u65B0\uFF09`
+    );
   }
-  const branch = branchNameForSession(trimmedSessionId);
-  return ensureFeatureBranch(branch, baselineBranch, options);
+  return { didUpdate: true };
 }
 
-// src/commands/clean-branches.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify4 } from "util";
-var execFileAsync4 = promisify4(execFile4);
-async function execGit3(cwd, args, quiet) {
-  try {
-    const { stdout, stderr } = await execFileAsync4("git", args, {
-      cwd,
-      encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024
-    });
-    if (!quiet && stderr.trim()) {
-      process.stderr.write(stderr);
-    }
-    return stdout;
-  } catch (err) {
-    const e = err;
-    const detail = (e.stderr ?? e.message ?? String(err)).trim();
-    throw new Error(
-      `[apm] git ${args.join(" ")} \u5931\u8D25${detail ? `: ${detail}` : ""}`
-    );
-  }
-}
-async function ensureGitRepo2(cwd) {
-  await execGit3(cwd, ["rev-parse", "--git-dir"], true);
-}
-async function getCurrentBranch2(cwd) {
-  return (await execGit3(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], true)).trim();
-}
-async function resolveDefaultBranch(cwd) {
-  try {
-    const ref = (await execGit3(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD"], true)).trim();
-    const match = ref.match(/^refs\/remotes\/origin\/(.+)$/);
-    if (match?.[1]) {
-      return match[1];
-    }
-  } catch {
-  }
-  const out = await execGit3(cwd, ["remote", "show", "origin"], true);
-  const headLine = out.split(/\r?\n/).find((line) => line.includes("HEAD branch"));
-  const branch = headLine?.split(":").pop()?.trim();
-  if (branch) {
-    return branch;
-  }
-  throw new Error("[apm] \u65E0\u6CD5\u89E3\u6790 origin \u9ED8\u8BA4\u5206\u652F\uFF0C\u8BF7\u5148\u6267\u884C git fetch origin");
-}
-async function listLocalSessionBranches(cwd) {
-  const out = await execGit3(
-    cwd,
-    [
-      "for-each-ref",
-      "--format=%(refname:short)",
-      "refs/heads/",
-      SESSION_BRANCH_PREFIX + "*"
-    ],
-    true
-  );
-  return out.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-}
-async function listRemoteSessionBranches(cwd) {
-  const out = await execGit3(
-    cwd,
-    [
-      "for-each-ref",
-      "--format=%(refname:short)",
-      "refs/remotes/origin/",
-      SESSION_BRANCH_PREFIX + "*"
-    ],
-    true
-  );
-  return out.split(/\r?\n/).map((line) => line.trim().replace(/^origin\//, "")).filter(Boolean);
-}
-async function localBranchExists2(cwd, branch) {
-  try {
-    await execGit3(
-      cwd,
-      ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
-      true
-    );
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function remoteBranchExists(cwd, branch) {
-  const out = await execGit3(
-    cwd,
-    ["ls-remote", "--heads", "origin", branch],
-    true
-  );
-  return out.trim().length > 0;
-}
-function reasonForCleanup(sessionId, sessionStatusById) {
-  if (!sessionStatusById.has(sessionId)) {
-    return "\u6C9F\u901A\u7FA4\u4E0D\u5728\u4EFB\u52A1\u5217\u8868\u4E2D";
-  }
-  if (sessionStatusById.get(sessionId) === "COMPLETED") {
-    return "\u5173\u8054\u4EFB\u52A1\u5DF2\u5B8C\u6210";
-  }
-  return "\u4FDD\u7559";
-}
-async function isBranchMergedIntoDefault(cwd, branch, defaultBranch) {
-  const ref = await localBranchExists2(cwd, branch) ? branch : `origin/${branch}`;
-  try {
-    await execGit3(
-      cwd,
-      ["merge-base", "--is-ancestor", ref, `origin/${defaultBranch}`],
-      true
-    );
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function runCleanBranches(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const dryRun = options.dryRun ?? false;
-  await ensureGitRepo2(cwd);
-  await execGit3(cwd, ["fetch", "--prune", "origin"], true);
-  const cfg = await ensureLoggedConfig();
-  const api = createApmApiClient(cfg);
-  const { sessions } = await api.cli.listSessionsForBranchCleanup({});
-  const sessionStatusById = new Map(
-    sessions.map((item) => [item.sessionId, item.taskStatus])
-  );
-  const branchNames = /* @__PURE__ */ new Set([
-    ...await listLocalSessionBranches(cwd),
-    ...await listRemoteSessionBranches(cwd)
-  ]);
-  if (branchNames.size === 0) {
-    console.log("[apm] \u672A\u53D1\u73B0 feat/session-* \u5206\u652F");
-    return;
-  }
-  const toDelete = [...branchNames].map((branch) => {
-    const sessionId = sessionIdFromBranchName(branch);
-    if (!sessionId) {
-      return null;
-    }
-    const reason = reasonForCleanup(sessionId, sessionStatusById);
-    if (reason === "\u4FDD\u7559") {
-      return null;
-    }
-    return { branch, sessionId, reason };
-  }).filter((item) => item != null).sort((a, b) => a.branch.localeCompare(b.branch));
-  if (toDelete.length === 0) {
-    console.log("[apm] \u6CA1\u6709\u9700\u8981\u6E05\u7406\u7684 feat/session-* \u5206\u652F");
-    return;
-  }
-  let currentBranch = await getCurrentBranch2(cwd);
-  let defaultBranch = null;
-  if (dryRun) {
-    defaultBranch = await resolveDefaultBranch(cwd);
-  }
-  for (const item of toDelete) {
-    const { branch, sessionId, reason } = item;
-    const label = `${branch} (${sessionId}: ${reason})`;
-    if (dryRun) {
-      const merged = await isBranchMergedIntoDefault(
-        cwd,
-        branch,
-        defaultBranch
-      );
-      const mergeTag = merged ? "\u5DF2\u5408\u5E76" : "\u672A\u5408\u5E76";
-      console.log(`[apm] [dry-run] \u5C06\u5220\u9664 ${label} [${mergeTag}]`);
-      continue;
-    }
-    if (currentBranch === branch) {
-      defaultBranch ??= await resolveDefaultBranch(cwd);
-      await execGit3(cwd, ["checkout", defaultBranch], true);
-      currentBranch = defaultBranch;
-    }
-    if (await localBranchExists2(cwd, branch)) {
-      await execGit3(cwd, ["branch", "-D", branch], true);
-      console.log(`[apm] \u5DF2\u5220\u9664\u672C\u5730\u5206\u652F ${branch}`);
-    }
-    if (await remoteBranchExists(cwd, branch)) {
-      await execGit3(cwd, ["push", "origin", "--delete", branch], true);
-      console.log(`[apm] \u5DF2\u5220\u9664\u8FDC\u7A0B\u5206\u652F origin/${branch}`);
-    }
-  }
-  if (dryRun) {
-    console.log(`[apm] [dry-run] \u5171 ${toDelete.length} \u4E2A\u5206\u652F\u5F85\u6E05\u7406`);
-  } else {
-    console.log(`[apm] \u5DF2\u6E05\u7406 ${toDelete.length} \u4E2A feat/session-* \u5206\u652F`);
-  }
-}
-
-// src/commands/pull.ts
-import { writeFileSync as writeFileSync9 } from "fs";
-import { join as join9 } from "path";
-import { stringify as yamlStringify } from "yaml";
-
-// src/session-messages-xml.ts
-function asXmlText(value) {
-  return value ?? "";
-}
-function escapeXmlAttr(value) {
-  return asXmlText(value).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function wrapCdata(value) {
-  return `<![CDATA[${asXmlText(value).replace(/]]>/g, "]]]]><![CDATA[>")}]]>`;
-}
-function formatSessionMessagesXml(sessionId, messages) {
-  const lines = [
-    '<?xml version="1.0" encoding="UTF-8"?>',
-    `<messages sessionId="${escapeXmlAttr(sessionId)}">`
-  ];
-  for (const message of messages) {
-    const roundAttr = message.round != null && message.round > 0 ? ` round="${message.round}"` : "";
-    lines.push(
-      `  <message id="${escapeXmlAttr(message.id)}" name="${escapeXmlAttr(
-        message.name
-      )}" agent="${escapeXmlAttr(message.oxcAgent)}"${roundAttr}>`,
-      `    <content>${wrapCdata(message.content)}</content>`,
-      "  </message>"
-    );
-  }
-  lines.push("</messages>", "");
-  return lines.join("\n");
-}
-
-// src/commands/sync-session-attachments.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join6 } from "path";
-var MANIFEST_FILE2 = ".sync-manifest.json";
-async function downloadAttachment(cfg, attachmentId) {
-  const base = cfg.baseUrl.trim().replace(/\/+$/, "");
-  const url = `${base}/api/v1/tasks/attachments/file?${new URLSearchParams({ attachmentId })}`;
-  const res = await fetch(url);
-  if (!res.ok) {
-    throw new Error(
-      `[apm] \u4E0B\u8F7D\u9644\u4EF6\u5931\u8D25 (${res.status}): attachmentId=${attachmentId}`
-    );
-  }
-  return Buffer.from(await res.arrayBuffer());
-}
-function loadManifest(dir) {
-  const path10 = join6(dir, MANIFEST_FILE2);
-  if (!existsSync4(path10)) {
-    return { version: 1, attachments: {} };
-  }
-  try {
-    const parsed = JSON.parse(
-      readFileSync5(path10, "utf8")
-    );
-    if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
-      return parsed;
-    }
-  } catch {
-  }
-  return { version: 1, attachments: {} };
-}
-function saveManifest(dir, manifest) {
-  writeFileSync6(
-    join6(dir, MANIFEST_FILE2),
-    `${JSON.stringify(manifest, null, 2)}
-`,
-    "utf8"
-  );
-}
-function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync4(dest)) return false;
-  if (entry.name !== item.name) return false;
-  const createdAt = item.createdAt ?? "";
-  return entry.createdAt === createdAt;
-}
-async function syncSessionAttachments(cfg, sessionId, attachments, apmRoot) {
-  const dir = join6(sessionDir(sessionId, apmRoot), SESSION_ATTACHMENTS_SUBDIR);
-  await ensureDirExists(dir);
-  if (attachments.length === 0) {
-    saveManifest(dir, { version: 1, attachments: {} });
-    return;
-  }
-  const manifest = loadManifest(dir);
-  const nextManifest = { version: 1, attachments: {} };
-  for (const item of attachments) {
-    const dest = join6(dir, item.name);
-    const entry = manifest.attachments[item.id];
-    const createdAt = item.createdAt ?? "";
-    if (isAttachmentUpToDate(entry, item, dest)) {
-      nextManifest.attachments[item.id] = entry;
-      console.log(
-        `[apm] \u9644\u4EF6\u65E0\u53D8\u5316\uFF0C\u5DF2\u8DF3\u8FC7: ${SESSION_ATTACHMENTS_SUBDIR}/${item.name}`
-      );
-      continue;
-    }
-    const buffer = await downloadAttachment(cfg, item.id);
-    writeFileSync6(dest, buffer);
-    nextManifest.attachments[item.id] = {
-      name: item.name,
-      createdAt
-    };
-    console.log(`[apm] \u5DF2\u4E0B\u8F7D\u9644\u4EF6: ${SESSION_ATTACHMENTS_SUBDIR}/${item.name}`);
-  }
-  saveManifest(dir, nextManifest);
-}
-
-// src/rules-sync.ts
-import { basename as basename2, extname as extname2, join as join8 } from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
+// src/commands/update-skills.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
+import { join as join8 } from "path";
 
 // src/skills-sync.ts
 import {
   copyFileSync as copyFileSync2,
   cpSync,
-  existsSync as existsSync5,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync3,
   readdirSync as readdirSync3,
   rmSync as rmSync2,
   statSync as statSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync6
 } from "fs";
 import { join as join7 } from "path";
 var AGENTS_TEMPLATE_PATH = join7(CLI_TEMPLATE_DIR, "AGENTS.md");
@@ -1494,20 +991,20 @@ function sanitizeSkillDirName(name) {
   return trimmed.replace(/[/\\:*?"<>|]/g, "_");
 }
 function listBaseSkillDirNames() {
-  if (!existsSync5(BASE_SKILLS_TEMPLATE_DIR)) return [];
+  if (!existsSync4(BASE_SKILLS_TEMPLATE_DIR)) return [];
   return readdirSync3(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
     const path10 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
     return statSync2(path10).isDirectory();
   });
 }
 function syncAgentsGuide(apmDir) {
-  if (!existsSync5(AGENTS_TEMPLATE_PATH)) return false;
+  if (!existsSync4(AGENTS_TEMPLATE_PATH)) return false;
   mkdirSync3(apmDir, { recursive: true });
   copyFileSync2(AGENTS_TEMPLATE_PATH, join7(apmDir, "AGENTS.md"));
   return true;
 }
 function listBaseRuleFileNames() {
-  if (!existsSync5(BASE_RULES_TEMPLATE_DIR)) return [];
+  if (!existsSync4(BASE_RULES_TEMPLATE_DIR)) return [];
   return readdirSync3(BASE_RULES_TEMPLATE_DIR).filter((name) => {
     const path10 = join7(BASE_RULES_TEMPLATE_DIR, name);
     return statSync2(path10).isFile();
@@ -1547,11 +1044,11 @@ function syncSupplementarySkills(skillsDir, list) {
     }
     const skillDir = join7(skillsDir, dirName);
     mkdirSync3(skillDir, { recursive: true });
-    writeFileSync7(join7(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
+    writeFileSync6(join7(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
     written.push(dirName);
   }
   const removed = [];
-  if (!existsSync5(skillsDir)) return { written, skipped, removed };
+  if (!existsSync4(skillsDir)) return { written, skipped, removed };
   for (const entry of readdirSync3(skillsDir)) {
     const full = join7(skillsDir, entry);
     if (!statSync2(full).isDirectory()) continue;
@@ -1563,263 +1060,11 @@ function syncSupplementarySkills(skillsDir, list) {
   return { written, skipped, removed };
 }
 
-// src/rules-sync.ts
-var MANIFEST_FILE3 = ".rules-sync-manifest.json";
-function ruleLocalFileName(ruleName) {
-  const trimmed = ruleName.trim();
-  if (!trimmed) return "rule.md";
-  const sanitized = trimmed.replace(/[/\\:*?"<>|]/g, "_");
-  if (extname2(sanitized).toLowerCase() === ".md") return sanitized;
-  return `${sanitized}.md`;
-}
-function loadManifest2(rulesDir) {
-  const path10 = join8(rulesDir, MANIFEST_FILE3);
-  if (!existsSync6(toFsPath(path10))) {
-    return { version: 1, rules: {} };
-  }
-  try {
-    const parsed = JSON.parse(
-      readFileSync6(toFsPath(path10), "utf8")
-    );
-    if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
-      return parsed;
-    }
-  } catch {
-  }
-  return { version: 1, rules: {} };
-}
-function saveManifest2(rulesDir, manifest) {
-  writeFileSync8(
-    toFsPath(join8(rulesDir, MANIFEST_FILE3)),
-    `${JSON.stringify(manifest, null, 2)}
-`,
-    "utf8"
-  );
-}
-function isBaseRuleFileName(fileName) {
-  return listBaseRuleFileNames().includes(basename2(fileName));
-}
-function isRuleUpToDate(entry, rule, dest) {
-  if (!entry || !existsSync6(toFsPath(dest))) return false;
-  if (entry.fileName !== ruleLocalFileName(rule.name)) return false;
-  const updatedAt = rule.updatedAt ?? "";
-  if (entry.updatedAt !== updatedAt) return false;
-  const localContent = readFileSync6(toFsPath(dest), "utf8");
-  return localContent === (rule.content ?? "");
-}
-async function syncPlatformRules(cfg, sessionId, workdirPath, apmRoot) {
-  const api = createApmApiClient(cfg);
-  const baseline = await api.cli.branchBaseline({ sessionId, workdirPath });
-  const repositoryId = baseline.repositoryId;
-  const rulesDir = join8(apmRoot ?? workspaceApmDir(workdirPath), "rules");
-  await ensureDirExists(rulesDir);
-  if (!repositoryId) {
-    console.log(
-      `[apm] \u672A\u5339\u914D\u5230\u7ED1\u5B9A\u4ED3\u5E93\u7684\u5DE5\u4F5C\u7A7A\u95F4\uFF0C\u8DF3\u8FC7\u5E73\u53F0\u89C4\u5219\u540C\u6B65\uFF08\u8DEF\u5F84\uFF1A${workdirPath}\uFF09`
-    );
-    return { written: [], skipped: [], removed: [], repositoryId: null };
-  }
-  const { list } = await api.cli.listRules({ repositoryId });
-  const manifest = loadManifest2(rulesDir);
-  const nextManifest = { version: 1, rules: {} };
-  const remoteIds = /* @__PURE__ */ new Set();
-  const written = [];
-  const skipped = [];
-  for (const rule of list) {
-    remoteIds.add(rule.id);
-    const fileName = ruleLocalFileName(rule.name);
-    const dest = join8(rulesDir, fileName);
-    const entry = manifest.rules[rule.id];
-    const updatedAt = rule.updatedAt ?? "";
-    if (isRuleUpToDate(entry, rule, dest)) {
-      nextManifest.rules[rule.id] = entry;
-      skipped.push(fileName);
-      console.log(`[apm] \u89C4\u5219\u65E0\u53D8\u5316\uFF0C\u5DF2\u8DF3\u8FC7: rules/${fileName}`);
-      continue;
-    }
-    writeFileSync8(toFsPath(dest), rule.content ?? "", "utf8");
-    nextManifest.rules[rule.id] = { fileName, updatedAt };
-    written.push(fileName);
-    console.log(`[apm] \u5DF2\u540C\u6B65\u5E73\u53F0\u89C4\u5219: rules/${fileName}`);
-  }
-  const removed = [];
-  for (const [ruleId, entry] of Object.entries(manifest.rules)) {
-    if (remoteIds.has(ruleId)) continue;
-    if (isBaseRuleFileName(entry.fileName)) continue;
-    const dest = join8(rulesDir, entry.fileName);
-    if (existsSync6(toFsPath(dest))) {
-      rmSync3(toFsPath(dest), { force: true });
-    }
-    removed.push(entry.fileName);
-    console.log(`[apm] \u5DF2\u79FB\u9664\u5DF2\u4E0B\u7EBF\u7684\u5E73\u53F0\u89C4\u5219: rules/${entry.fileName}`);
-  }
-  saveManifest2(rulesDir, nextManifest);
-  return { written, skipped, removed, repositoryId };
-}
-
-// src/commands/pull.ts
-async function runPull(sessionId, remoteWorkdir) {
-  const trimmedId = sessionId.trim();
-  if (!trimmedId) {
-    console.error("[apm] sessionId \u4E0D\u80FD\u4E3A\u7A7A");
-    process.exit(1);
-  }
-  const cfg = await ensureLoggedConfig();
-  const api = createApmApiClient(cfg);
-  const workdir = remoteWorkdir === void 0 ? resolveWorkdirPath() : requireRemoteWorkdir(remoteWorkdir);
-  const apmRoot = workspaceApmDir(workdir);
-  const [detail, members, documents, attachments, messages] = await Promise.all(
-    [
-      api.cli.sessionDetail({ sessionId: trimmedId }),
-      api.cli.sessionMembers({ sessionId: trimmedId }),
-      api.cli.listDocuments({ sessionId: trimmedId }),
-      api.cli.listAttachments({ sessionId: trimmedId }),
-      api.cli.listSessionMessages({ sessionId: trimmedId })
-    ]
-  );
-  const dir = sessionDir(trimmedId, apmRoot);
-  const docsDir = sessionDocsDir(trimmedId, apmRoot);
-  await ensureDirExists(docsDir);
-  writeFileSync9(
-    sessionRulePath(trimmedId, apmRoot),
-    detail.description ?? "",
-    "utf8"
-  );
-  writeFileSync9(
-    sessionTaskPath(trimmedId, apmRoot),
-    detail.task.description ?? "",
-    "utf8"
-  );
-  writeFileSync9(sessionTodoPath(trimmedId, apmRoot), detail.todo ?? "", "utf8");
-  for (const doc of documents) {
-    const fileName = documentLocalFileName(doc.name);
-    writeFileSync9(join9(docsDir, fileName), doc.content ?? "", "utf8");
-  }
-  const sessionYaml = yamlStringify(
-    {
-      name: detail.title,
-      task: "./TASK.md",
-      todo: "./TODO.md",
-      rule: "./RULE.md",
-      members: members.map((m) => ({
-        name: m.displayName,
-        oxcAgent: m.oxcAgent,
-        description: m.description ?? ""
-      })),
-      attachments: attachments.map((a) => ({ name: a.name }))
-    },
-    { lineWidth: 0 }
-  );
-  writeFileSync9(
-    sessionYamlPath(trimmedId, apmRoot),
-    sessionYaml.endsWith("\n") ? sessionYaml : `${sessionYaml}
-`,
-    "utf8"
-  );
-  writeFileSync9(
-    sessionMessagesXmlPath(trimmedId, apmRoot),
-    formatSessionMessagesXml(trimmedId, messages),
-    "utf8"
-  );
-  await syncSessionAttachments(cfg, trimmedId, attachments, apmRoot);
-  await syncPlatformRules(cfg, trimmedId, workdir, apmRoot);
-  await syncRemoteDeploymentConfig(workdir, apmRoot);
-  await syncRepositoryProjectDocumentsPull(workdir, apmRoot);
-  console.log(`[apm] \u5DF2\u540C\u6B65\u4F1A\u8BDD\u5DE5\u4F5C\u533A: ${dir}`);
-  return dir;
-}
-
-// src/commands/update.ts
-import { spawnSync } from "child_process";
-
-// src/version.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname3, join as join10 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var CLI_PACKAGE_NAME = "ai-project-manage-cli";
-function readCliVersion() {
-  try {
-    const dir = dirname3(fileURLToPath2(import.meta.url));
-    const pkgPath = join10(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
-// src/commands/update.ts
-var useNpmShell = process.platform === "win32";
-function runNpm(args, options = {}) {
-  return spawnSync(useNpmShell ? "npm.cmd" : "npm", args, {
-    ...options,
-    shell: useNpmShell
-  });
-}
-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`;
-  try {
-    const res = await fetch(url);
-    if (!res.ok) return null;
-    const data = await res.json();
-    return data.version?.trim() || null;
-  } catch {
-    return null;
-  }
-}
-function npmAvailable() {
-  const r = runNpm(["--version"], { encoding: "utf8" });
-  return !r.error && r.status === 0;
-}
-async function runUpdate() {
-  const current = readCliVersion();
-  const latest = await fetchLatestPublishedVersion();
-  if (latest && current === latest) {
-    console.log(`[apm] \u5DF2\u662F\u6700\u65B0\u7248\u672C ${current}`);
-    return { didUpdate: false };
-  }
-  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`
-    );
-    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`
-  );
-  const install = runNpm(["install", "-g", `${CLI_PACKAGE_NAME}@latest`], {
-    stdio: "inherit"
-  });
-  if (install.error) {
-    console.error("[apm] \u66F4\u65B0\u5931\u8D25:", install.error.message);
-    process.exit(1);
-  }
-  if (install.status !== 0) {
-    process.exit(install.status ?? 1);
-  }
-  const after = readCliVersion();
-  if (latest && after === latest) {
-    console.log(`[apm] \u5DF2\u66F4\u65B0\u5230 ${after}`);
-  } else {
-    console.log(
-      `[apm] \u66F4\u65B0\u5B8C\u6210\u3002\u82E5\u7248\u672C\u53F7\u672A\u53D8\u5316\uFF0C\u8BF7\u5728\u65B0\u7EC8\u7AEF\u6267\u884C apm -V \u786E\u8BA4\uFF08\u5168\u5C40\u5B89\u88C5\u8DEF\u5F84\u53EF\u80FD\u672A\u5237\u65B0\uFF09`
-    );
-  }
-  return { didUpdate: true };
-}
-
 // src/commands/update-skills.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
-import { join as join11 } from "path";
 async function syncWorkspaceSkills(cfg, workdir) {
   const apmDir = workspaceApmDir(workdir);
   const fsApmDir = toFsPath(apmDir);
-  if (!existsSync7(fsApmDir)) {
+  if (!existsSync5(fsApmDir)) {
     throw new Error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
   }
   const apmStat = statSync3(fsApmDir);
@@ -1831,12 +1076,12 @@ async function syncWorkspaceSkills(cfg, workdir) {
   if (syncAgentsGuide(apmDir)) {
     console.log("[apm] \u5DF2\u540C\u6B65 APM \u6307\u5357: .apm/AGENTS.md");
   }
-  const rulesDir = join11(apmDir, "rules");
+  const rulesDir = join8(apmDir, "rules");
   const ruleNames = syncBaseRules(rulesDir);
   for (const name of ruleNames) {
     console.log(`[apm] \u5DF2\u540C\u6B65\u57FA\u7840\u89C4\u5219: rules/${name}`);
   }
-  const skillsDir = join11(apmDir, "skills");
+  const skillsDir = join8(apmDir, "skills");
   mkdirSync4(toFsPath(skillsDir), { recursive: true });
   const baseNames = syncBaseSkills(skillsDir);
   for (const name of baseNames) {
@@ -1863,7 +1108,7 @@ async function syncWorkspaceSkills(cfg, workdir) {
 }
 async function runUpdateSkills() {
   const apmDir = workspaceApmDir();
-  if (!existsSync7(apmDir)) {
+  if (!existsSync5(apmDir)) {
     console.error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
     process.exit(1);
   }
@@ -1875,197 +1120,6 @@ async function runUpdateSkills() {
   await syncWorkspaceSkills(cfg, resolveWorkdirPath());
 }
 
-// src/commands/sync-deploy-config.ts
-import { existsSync as existsSync8, statSync as statSync4 } from "fs";
-async function runSyncDeployConfig() {
-  const workdir = resolveWorkdirPath();
-  const apmDir = workspaceApmDir(workdir);
-  if (!existsSync8(apmDir)) {
-    console.error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
-    process.exit(1);
-  }
-  const apmStat = statSync4(apmDir);
-  if (!apmStat.isDirectory()) {
-    throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${apmDir}`);
-  }
-  await ensureLoggedConfig();
-  const result = await syncRemoteDeploymentConfig(workdir, apmDir);
-  if (!result.synced) {
-    process.exit(1);
-  }
-}
-
-// src/commands/sync-project-documents.ts
-async function runSyncProjectDocuments(options) {
-  const pull = options?.pull ?? !options?.push;
-  const push = options?.push ?? false;
-  const workdir = resolveWorkdirPath();
-  const apmRoot = workspaceApmDir(workdir);
-  if (pull) {
-    await syncRepositoryProjectDocumentsPull(workdir, apmRoot);
-  }
-  if (push) {
-    const cfg = await ensureLoggedConfig();
-    await syncRepositoryProjectDocumentsPush(cfg, workdir, apmRoot);
-  }
-}
-
-// src/commands/sync-document.ts
-import { existsSync as existsSync10 } from "fs";
-import { basename as basename3 } from "path";
-
-// src/commands/sync-session-documents.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
-import { join as join12 } from "path";
-function listLocalMarkdownFiles(docsDir) {
-  if (!existsSync9(docsDir)) {
-    return [];
-  }
-  return readdirSync4(docsDir).filter(
-    (name) => name.toLowerCase().endsWith(".md")
-  );
-}
-function remoteDocumentByLocalName(remoteDocuments, localFileName) {
-  const platformName = documentPlatformName(localFileName);
-  return remoteDocuments.find((doc) => {
-    const remoteLocalName = documentLocalFileName(doc.name);
-    return remoteLocalName === localFileName || documentPlatformName(doc.name) === platformName;
-  });
-}
-async function upsertLocalDocumentFile(api, sessionId, docsDir, fileName) {
-  const absPath = join12(docsDir, fileName);
-  const content = readFileSync8(absPath, "utf8");
-  const name = documentPlatformName(absPath);
-  return api.cli.upsertDocument({
-    sessionId,
-    name,
-    content
-  });
-}
-async function syncSessionDocuments(cfg, sessionId, apmRoot, options) {
-  const trimmedSessionId = sessionId.trim();
-  if (!trimmedSessionId) {
-    return 0;
-  }
-  const docsDir = sessionDocsDir(trimmedSessionId, apmRoot);
-  const localFiles = listLocalMarkdownFiles(docsDir);
-  if (localFiles.length === 0) {
-    return 0;
-  }
-  const api = options?.api ?? createApmApiClient(cfg);
-  const remoteDocuments = options?.remoteDocuments ?? await api.cli.listDocuments({ sessionId: trimmedSessionId });
-  let synced = 0;
-  for (const fileName of localFiles) {
-    const absPath = join12(docsDir, fileName);
-    const content = readFileSync8(absPath, "utf8");
-    const remote = remoteDocumentByLocalName(remoteDocuments, fileName);
-    if (remote && remote.content === content) {
-      continue;
-    }
-    const doc = await upsertLocalDocumentFile(
-      api,
-      trimmedSessionId,
-      docsDir,
-      fileName
-    );
-    synced += 1;
-    console.log(`[apm] \u5DF2\u540C\u6B65\u6587\u6863: ${doc.name} (id=${doc.id})`);
-  }
-  if (synced === 0) {
-    console.log("[apm] \u4F1A\u8BDD\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
-  }
-  return synced;
-}
-
-// src/commands/sync-document.ts
-async function runSyncDocument(sessionId, options) {
-  const trimmedSessionId = sessionId.trim();
-  if (!trimmedSessionId) {
-    console.error("[apm] sessionId \u4E0D\u80FD\u4E3A\u7A7A");
-    process.exit(1);
-  }
-  const fileArg = options.file?.trim();
-  if (!fileArg) {
-    console.error("[apm] \u8BF7\u6307\u5B9A --file <\u6587\u6863\u540D\u79F0>");
-    process.exit(1);
-  }
-  const absPath = resolveSessionDocumentPath(trimmedSessionId, fileArg);
-  if (!existsSync10(absPath)) {
-    const docsDir2 = sessionDocsDir(trimmedSessionId);
-    console.error(
-      `[apm] \u6587\u6863\u4E0D\u5B58\u5728: ${absPath}
-[apm] \u8BF7\u786E\u8BA4\u5DF2 pull\uFF0C\u4E14 ${docsDir2} \u4E0B\u5B58\u5728\u5BF9\u5E94\u6587\u4EF6`
-    );
-    process.exit(1);
-  }
-  const cfg = await ensureLoggedConfig();
-  const api = createApmApiClient(cfg);
-  const docsDir = sessionDocsDir(trimmedSessionId);
-  const doc = await upsertLocalDocumentFile(
-    api,
-    trimmedSessionId,
-    docsDir,
-    basename3(absPath)
-  );
-  console.log(`[apm] \u5DF2\u540C\u6B65\u6587\u6863: ${doc.name} (id=${doc.id})`);
-}
-
-// src/commands/append-message.ts
-async function appendMessageContent(cfg, messageId, content) {
-  const trimmedId = messageId.trim();
-  if (!trimmedId) {
-    throw new Error("messageId \u4E0D\u80FD\u4E3A\u7A7A");
-  }
-  if (!content) {
-    throw new Error("content \u4E0D\u80FD\u4E3A\u7A7A");
-  }
-  const api = createApmApiClient(cfg);
-  await api.cli.appendMessageContent({ id: trimmedId, content });
-}
-async function runAppendMessage(options) {
-  const messageId = options.id?.trim();
-  if (!messageId) {
-    console.error("[apm] \u8BF7\u6307\u5B9A --id <messageId>");
-    process.exit(1);
-  }
-  const content = options.content ?? "";
-  if (!content) {
-    console.error("[apm] \u8BF7\u6307\u5B9A --content <\u5185\u5BB9>");
-    process.exit(1);
-  }
-  const cfg = await ensureLoggedConfig();
-  await appendMessageContent(cfg, messageId, content);
-  console.log(`[apm] \u5DF2\u8FFD\u52A0\u6D88\u606F\u5185\u5BB9: ${messageId}`);
-}
-
-// src/commands/update-message-status.ts
-var VALID_STATUSES = [
-  "CREATED",
-  "QUEUED",
-  "TYPING",
-  "SUCCESS",
-  "FAILED",
-  "CANCELLED"
-];
-async function runUpdateMessageStatus(options) {
-  const messageId = options.id?.trim();
-  const status = options.status?.trim().toUpperCase();
-  if (!messageId) {
-    console.error("[apm] \u8BF7\u6307\u5B9A --id <messageId>");
-    process.exit(1);
-  }
-  if (!VALID_STATUSES.includes(status)) {
-    console.error(
-      `[apm] \u65E0\u6548\u72B6\u6001: ${options.status}\uFF0C\u53EF\u9009: ${VALID_STATUSES.join(", ")}`
-    );
-    process.exit(1);
-  }
-  const cfg = await ensureLoggedConfig();
-  const api = createApmApiClient(cfg);
-  await api.cli.updateMessageStatus({ id: messageId, status });
-  console.log(`[apm] \u5DF2\u66F4\u65B0\u6D88\u606F\u72B6\u6001: ${messageId} \u2192 ${status}`);
-}
-
 // src/commands/connect.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import WebSocket from "ws";
@@ -2093,57 +1147,6 @@ function validateHeartbeat(o) {
   }
   return { ok: true, data: { type: "heartbeat", userId: o.userId.trim() } };
 }
-function validateMessagePush(o) {
-  if (o.type !== "message") {
-    return { ok: false, reason: "\u671F\u671B message" };
-  }
-  if (!nonEmptyString(o.messageId)) {
-    return { ok: false, reason: "message \u7F3A\u5C11 messageId" };
-  }
-  if (!nonEmptyString(o.sessionId)) {
-    return { ok: false, reason: "message \u7F3A\u5C11 sessionId" };
-  }
-  if (!nonEmptyString(o.content)) {
-    return { ok: false, reason: "message \u7F3A\u5C11 content" };
-  }
-  if (!nonEmptyString(o.model)) {
-    return { ok: false, reason: "message \u7F3A\u5C11 model" };
-  }
-  if (!nonEmptyString(o.apiKey)) {
-    return { ok: false, reason: "message \u7F3A\u5C11 apiKey" };
-  }
-  if (!nonEmptyString(o.workdir)) {
-    return { ok: false, reason: "message \u7F3A\u5C11 workdir" };
-  }
-  if (!nonEmptyString(o.user)) {
-    return { ok: false, reason: "message \u7F3A\u5C11 user" };
-  }
-  return {
-    ok: true,
-    data: {
-      type: "message",
-      messageId: o.messageId.trim(),
-      sessionId: o.sessionId.trim(),
-      content: o.content,
-      model: o.model.trim(),
-      apiKey: o.apiKey.trim(),
-      workdir: o.workdir.trim(),
-      user: o.user.trim()
-    }
-  };
-}
-function validateCancel(o) {
-  if (o.type !== "cancel") {
-    return { ok: false, reason: "\u671F\u671B cancel" };
-  }
-  if (!nonEmptyString(o.messageId)) {
-    return { ok: false, reason: "cancel \u7F3A\u5C11 messageId" };
-  }
-  return {
-    ok: true,
-    data: { type: "cancel", messageId: o.messageId.trim() }
-  };
-}
 function validateDeployPush(o) {
   if (o.type !== "deploy") {
     return { ok: false, reason: "\u671F\u671B deploy" };
@@ -2168,103 +1171,26 @@ 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"
-    };
+function validateReceivedMailPush(o) {
+  if (o.type !== "received_mail") {
+    return { ok: false, reason: "\u671F\u671B received_mail" };
   }
-  if (!validateCoordinatorDispatchMode(o.mode)) {
-    return { ok: false, reason: "coordinator_dispatch_resume.mode \u65E0\u6548" };
+  if (!nonEmptyString(o.id)) {
+    return { ok: false, reason: "received_mail \u7F3A\u5C11 id" };
   }
-  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.taskId)) {
+    return { ok: false, reason: "received_mail \u7F3A\u5C11 taskId" };
   }
-  if (!nonEmptyString(o.user)) {
-    return { ok: false, reason: "coordinator_dispatch_resume \u7F3A\u5C11 user" };
+  if (!nonEmptyString(o.createdAt)) {
+    return { ok: false, reason: "received_mail \u7F3A\u5C11 createdAt" };
   }
   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()
+      type: "received_mail",
+      id: o.id.trim(),
+      taskId: o.taskId.trim(),
+      createdAt: o.createdAt.trim()
     }
   };
 }
@@ -2274,36 +1200,27 @@ function validateAgentWsMessage(value, kind) {
   }
   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 !== "deploy" && type !== "received_mail") {
     return { ok: false, reason: `\u672A\u77E5 type: ${String(type)}` };
   }
   if (kind === "heartbeat" || type === "heartbeat") {
     return validateHeartbeat(o);
   }
-  if (type === "cancel") {
-    return validateCancel(o);
-  }
   if (type === "deploy") {
     return validateDeployPush(o);
   }
-  if (type === "coordinator_dispatch") {
-    return validateCoordinatorDispatchPush(o);
-  }
-  if (type === "coordinator_dispatch_resume") {
-    return validateCoordinatorDispatchResumePush(o);
-  }
-  return validateMessagePush(o);
+  return validateReceivedMailPush(o);
 }
 
 // src/commands/connect/deploy-run.ts
 import { spawn } from "node:child_process";
-import { readFileSync as readFileSync9 } from "node:fs";
-import { join as join13 } from "node:path";
+import { readFileSync as readFileSync6 } from "node:fs";
+import { join as join9 } from "node:path";
 var DEPLOY_LOG_SYNC_INTERVAL_MS = 3e4;
 function readDeployConfig(workdir) {
-  const configPath = join13(workspaceApmDir(workdir), "apm.config.json");
+  const configPath = join9(workspaceApmDir(workdir), "apm.config.json");
   try {
-    const raw = readFileSync9(configPath, "utf8");
+    const raw = readFileSync6(configPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.deploy;
   } catch {
@@ -2378,7 +1295,7 @@ function createDeployLogSyncer(api, deploymentRunId) {
     if (!latestLog || latestLog === lastSyncedLog) {
       return;
     }
-    await api.cli.syncCoordinatorDeploymentLog({
+    await api.cli.syncTaskDeploymentLog({
       id: deploymentRunId,
       log: latestLog
     });
@@ -2409,7 +1326,7 @@ async function handleInboundDeploy(cfg, msg, signal) {
   const api = createApmApiClient(cfg);
   const deploymentRunId = msg.deploymentRunId;
   if (signal.aborted) return;
-  await api.cli.updateCoordinatorDeploymentStatus({
+  await api.cli.updateTaskDeploymentStatus({
     id: deploymentRunId,
     status: "DEPLOYING"
   });
@@ -2418,7 +1335,7 @@ async function handleInboundDeploy(cfg, msg, signal) {
   if (!command) {
     const error = missingDeployCommandMessage(msg.environment);
     console.error(`[apm] ${error}`);
-    await api.cli.completeCoordinatorDeployment({
+    await api.cli.completeTaskDeployment({
       id: deploymentRunId,
       status: "FAILED",
       log: error,
@@ -2440,7 +1357,7 @@ async function handleInboundDeploy(cfg, msg, signal) {
     latestLog = log;
     logSyncer.updateLog(log);
     await logSyncer.flush();
-    await api.cli.completeCoordinatorDeployment({
+    await api.cli.completeTaskDeployment({
       id: deploymentRunId,
       status: "SUCCESS",
       log
@@ -2451,7 +1368,7 @@ async function handleInboundDeploy(cfg, msg, signal) {
     const log = error && typeof error === "object" && "log" in error ? String(error.log ?? latestLog) : latestLog;
     logSyncer.updateLog(log);
     await logSyncer.flush();
-    await api.cli.completeCoordinatorDeployment({
+    await api.cli.completeTaskDeployment({
       id: deploymentRunId,
       status: "FAILED",
       log,
@@ -2463,6 +1380,68 @@ async function handleInboundDeploy(cfg, msg, signal) {
   }
 }
 
+// src/commands/sync-task-documents.ts
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync7 } from "fs";
+import { join as join10 } from "path";
+function listLocalMarkdownFiles(docsDir) {
+  if (!existsSync6(docsDir)) {
+    return [];
+  }
+  return readdirSync4(docsDir).filter(
+    (name) => name.toLowerCase().endsWith(".md")
+  );
+}
+function remoteDocumentByLocalName(remoteDocuments, localFileName) {
+  const platformName = documentPlatformName(localFileName);
+  return remoteDocuments.find((doc) => {
+    const remoteLocalName = documentLocalFileName(doc.name);
+    return remoteLocalName === localFileName || documentPlatformName(doc.name) === platformName;
+  });
+}
+async function upsertLocalDocumentFile(api, taskId, docsDir, fileName) {
+  const content = readFileSync7(join10(docsDir, fileName), "utf8");
+  const name = documentPlatformName(join10(docsDir, fileName));
+  return api.cli.upsertDocument({
+    taskId,
+    name,
+    content
+  });
+}
+async function syncTaskDocuments(cfg, taskId, workdir, options) {
+  const trimmedTaskId = taskId.trim();
+  if (!trimmedTaskId) {
+    return 0;
+  }
+  const apmRoot = workspaceApmDir(workdir);
+  const docsDir = taskDocsDir(trimmedTaskId, apmRoot, workdir);
+  const localFiles = listLocalMarkdownFiles(docsDir);
+  if (localFiles.length === 0) {
+    return 0;
+  }
+  const api = options?.api ?? createApmApiClient(cfg);
+  const remoteDocuments = options?.remoteDocuments ?? await api.cli.listDocuments({ taskId: trimmedTaskId });
+  let synced = 0;
+  for (const fileName of localFiles) {
+    const content = readFileSync7(join10(docsDir, fileName), "utf8");
+    const remote = remoteDocumentByLocalName(remoteDocuments, fileName);
+    if (remote && remote.content === content) {
+      continue;
+    }
+    const doc = await upsertLocalDocumentFile(
+      api,
+      trimmedTaskId,
+      docsDir,
+      fileName
+    );
+    synced += 1;
+    console.log(`[apm] \u5DF2\u540C\u6B65\u6587\u6863: ${doc.name} (id=${doc.id})`);
+  }
+  if (synced === 0) {
+    console.log("[apm] \u4EFB\u52A1\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
+  }
+  return synced;
+}
+
 // src/commands/connect/cursor-agent.ts
 import {
   Agent,
@@ -2470,28 +1449,87 @@ import {
 } from "@cursor/sdk";
 import { setMaxListeners as setMaxListeners2 } from "node:events";
 
-// src/plan-format.ts
-function formatPlanMarkdown(raw) {
-  let text = raw.trim();
-  if (!text) {
-    return text;
+// src/commands/connect/plan-document.ts
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join11 } from "node:path";
+function normalizePlanContent(plan) {
+  return plan.replace(/\\n/g, "\n").trim();
+}
+function extractPlanFromArgs(args) {
+  if (args == null) {
+    return void 0;
   }
-  if (text.startsWith("{") && text.endsWith("}")) {
+  let parsed = args;
+  if (typeof args === "string") {
+    const trimmed = args.trim();
+    if (!trimmed) {
+      return void 0;
+    }
     try {
-      const parsed = JSON.parse(text);
-      if (typeof parsed.plan === "string") {
-        return formatPlanMarkdown(parsed.plan);
-      }
+      parsed = JSON.parse(trimmed);
     } catch {
+      return normalizePlanContent(trimmed);
+    }
+  }
+  if (typeof parsed === "object" && parsed !== null && "plan" in parsed) {
+    const plan = parsed.plan;
+    if (typeof plan === "string" && plan.trim()) {
+      return normalizePlanContent(plan);
+    }
+  }
+  return void 0;
+}
+function memberPlanFileName(displayName) {
+  const sanitized = displayName.trim().replace(/[/\\:*?"<>|]/g, "-").replace(/\s+/g, " ").trim() || "member";
+  return `${sanitized}-PLAN.md`;
+}
+function collectCreatePlanContent(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.type !== "tool_call") continue;
+    if (event.name !== "createPlan") continue;
+    if (event.status !== "completed") continue;
+    const content = extractPlanFromArgs(event.args);
+    if (content) {
+      return content;
+    }
+  }
+  return void 0;
+}
+function extractCreatePlanFromSessionEvents(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.type !== "tool_call") continue;
+    if (event.name !== "createPlan") continue;
+    if (event.status !== "completed") continue;
+    const content = extractPlanFromArgs(event.args);
+    if (content) {
+      return content;
     }
   }
-  if (!text.includes("\n") && text.includes("\\n")) {
-    text = text.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  return void 0;
+}
+function saveMemberPlanDocument(input) {
+  const trimmedContent = input.content.trim();
+  if (!trimmedContent) {
+    throw new Error("\u8BA1\u5212\u5185\u5BB9\u4E3A\u7A7A\uFF0C\u65E0\u6CD5\u4FDD\u5B58\u6587\u6863");
   }
-  return text.replace(/\r\n/g, "\n").trimEnd() + "\n";
+  const fileName = memberPlanFileName(input.memberDisplayName);
+  const docsDir = taskDocsDir(
+    input.taskId,
+    workspaceApmDir(input.workdir),
+    input.workdir
+  );
+  mkdirSync5(toFsPath(docsDir), { recursive: true });
+  const filePath = join11(docsDir, fileName);
+  const normalized = trimmedContent.endsWith("\n") ? trimmedContent : `${trimmedContent}
+`;
+  writeFileSync7(toFsPath(filePath), normalized, "utf8");
+  console.log(`[apm] \u5DF2\u4FDD\u5B58\u8BA1\u5212\u6587\u6863: ${fileName}`);
+  return fileName;
 }
 
-// src/session-utils.ts
+// src/event-session.ts
 var EventSession = class {
   events = [];
   dirtyIndices = /* @__PURE__ */ new Set();
@@ -2538,10 +1576,10 @@ var EventSession = class {
     if (latestEvent?.type === formatedEvent.type) {
       switch (formatedEvent.type) {
         case "assistant":
-          latestEvent.content += formatedEvent.content;
+          latestEvent.content = String(latestEvent.content ?? "") + formatedEvent.content;
           break;
         case "thinking":
-          latestEvent.content += formatedEvent.content;
+          latestEvent.content = String(latestEvent.content ?? "") + formatedEvent.content;
           break;
         case "task":
           latestEvent.status = formatedEvent.status;
@@ -2612,72 +1650,49 @@ var EventSession = class {
       this.dirtyIndices.delete(index);
     }
   }
-  /** 合并所有 assistant 片段，供剧场成员回传等场景使用 */
   getAssistantText() {
     return this.events.filter((e) => e.type === "assistant").map((e) => String(e.content ?? "")).join("\n").trim();
   }
-  /** plan 模式下 createPlan 工具 completed 时的 plan 字段（取最后一次） */
   getCreatePlanContent() {
-    for (let i = this.events.length - 1; i >= 0; i--) {
-      const event = this.events[i];
-      if (event.type !== "tool_call") {
-        continue;
-      }
-      if (event.name !== "createPlan" || event.status !== "completed") {
-        continue;
-      }
-      const plan = event.args?.plan;
-      if (typeof plan === "string" && plan.trim()) {
-        return formatPlanMarkdown(plan);
-      }
-    }
-    return void 0;
-  }
-  resolveLogContent() {
-    return this.events.map((event) => formatLogEvent(event.type, event)).join("\n");
+    return extractCreatePlanFromSessionEvents(this.events);
   }
 };
-function formatLogEvent(type, event) {
-  if (type === "input") {
-    return `## \u7528\u6237\u8F93\u5165
-
-${String(event.content ?? "")}
-`;
-  }
-  if (type === "assistant") {
-    return `## \u6A21\u578B\u8F93\u51FA
 
-${String(event.content ?? "")}
-`;
-  }
-  if (type === "thinking") {
-    return `## \u6A21\u578B\u601D\u8003
-
-${String(event.content ?? "")}
-`;
-  }
-  if (type === "tool_call") {
-    return "````toolcall\n" + JSON.stringify(event, null, 2) + "\n````\n";
+// 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)`;
   }
-  return `## \u672A\u77E5\u4E8B\u4EF6\uFF1A${type}
-
-\`\`\`json
-${JSON.stringify(event, null, 2)}
-\`\`\``;
+  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));
 }
 
-// src/commands/connect/agent-session-registry.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "node:fs";
+// src/commands/connect/agent-task-registry.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "node:fs";
 import { dirname as dirname4, resolve as resolve3 } from "node:path";
-function registryPath(workdir, sessionId) {
-  return resolve3(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
+function registryPath(workdir, taskId) {
+  return resolve3(workdir, ".apm", "tasks", taskId, "cursor-agents.json");
 }
 function readRegistry(path10) {
-  if (!existsSync11(path10)) {
+  if (!existsSync7(path10)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync10(path10, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path10, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const result = {};
       for (const [key, value] of Object.entries(
@@ -2694,22 +1709,21 @@ function readRegistry(path10) {
   return {};
 }
 function writeRegistry(path10, registry) {
-  mkdirSync5(dirname4(path10), { recursive: true });
-  writeFileSync10(path10, `${JSON.stringify(registry, null, 2)}
+  mkdirSync6(dirname4(path10), { recursive: true });
+  writeFileSync8(path10, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
-function loadSessionAgentId(workdir, sessionId, user) {
-  const registry = readRegistry(registryPath(workdir, sessionId));
-  return registry[user];
+function loadTaskAgentId(workdir, taskId, user) {
+  return readRegistry(registryPath(workdir, taskId))[user];
 }
-function saveSessionAgentId(workdir, sessionId, user, agentId) {
-  const path10 = registryPath(workdir, sessionId);
+function saveTaskAgentId(workdir, taskId, user, agentId) {
+  const path10 = registryPath(workdir, taskId);
   const registry = readRegistry(path10);
   registry[user] = agentId;
   writeRegistry(path10, registry);
 }
-function clearSessionAgentId(workdir, sessionId, user) {
-  const path10 = registryPath(workdir, sessionId);
+function clearTaskAgentId(workdir, taskId, user) {
+  const path10 = registryPath(workdir, taskId);
   const registry = readRegistry(path10);
   if (!(user in registry)) {
     return;
@@ -2718,9 +1732,9 @@ function clearSessionAgentId(workdir, sessionId, user) {
   writeRegistry(path10, registry);
 }
 
-// src/commands/connect/cursor-message-log.ts
-var CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS = 2e3;
-function createThrottledCursorMessageLogSync(cfg, ctx, onError) {
+// src/commands/connect/cursor-log.ts
+var CURSOR_LOG_SYNC_INTERVAL_MS = 2e3;
+function createThrottledCursorLogSync(cfg, ctx, onError) {
   let lastRunAt = 0;
   let timer;
   let latestSession;
@@ -2732,7 +1746,7 @@ function createThrottledCursorMessageLogSync(cfg, ctx, onError) {
     }
     lastRunAt = Date.now();
     try {
-      await syncCursorMessageLog(cfg, ctx, events);
+      await syncCursorLog(cfg, ctx, events);
       session.clearDirty(events.map((event) => event.index));
     } catch (err) {
       onError(err);
@@ -2751,7 +1765,7 @@ function createThrottledCursorMessageLogSync(cfg, ctx, onError) {
       latestSession = session;
       const now = Date.now();
       const elapsed = now - lastRunAt;
-      if (elapsed >= CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS) {
+      if (elapsed >= CURSOR_LOG_SYNC_INTERVAL_MS) {
         if (timer) {
           clearTimeout(timer);
           timer = void 0;
@@ -2765,7 +1779,7 @@ function createThrottledCursorMessageLogSync(cfg, ctx, onError) {
       timer = setTimeout(() => {
         timer = void 0;
         enqueueSync(latestSession);
-      }, CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS - elapsed);
+      }, CURSOR_LOG_SYNC_INTERVAL_MS - elapsed);
     },
     async flush(session) {
       latestSession = session;
@@ -2778,336 +1792,51 @@ function createThrottledCursorMessageLogSync(cfg, ctx, onError) {
     }
   };
 }
-async function syncCursorMessageLog(cfg, ctx, events) {
+async function syncCursorLog(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,
+  await api.cli.upsertCursorLog({
+    taskId: ctx.taskId,
+    mailboxMessageId: ctx.mailboxMessageId,
     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";
-        }
-        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`;
-      }
-    }
-  };
-}
-
-// src/commands/connect/append-message-tool.ts
-function createAppendMessageCustomTools(cfg, messageId) {
-  return {
-    append_message: {
-      description: "\u5411\u5F53\u524D\u4F1A\u8BDD\u6D88\u606F\u8FFD\u52A0\u56DE\u590D\u5185\u5BB9\u3002\u53EF\u591A\u6B21\u8C03\u7528\u8865\u5145\u8FDB\u5C55\uFF1B\u88AB @ \u65F6\u6536\u5230\u540E\u5E94\u5148\u7B80\u77ED\u786E\u8BA4\u518D\u6267\u884C\u4EFB\u52A1\u3002",
-      inputSchema: {
-        type: "object",
-        properties: {
-          content: {
-            type: "string",
-            description: "\u8981\u53D1\u9001\u5230\u7FA4\u91CC\u7684\u56DE\u590D\u5185\u5BB9"
-          }
-        },
-        required: ["content"]
-      },
-      execute: async (args) => {
-        const content = typeof args.content === "string" ? args.content.trim() : "";
-        if (!content) {
-          return {
-            content: [{ type: "text", text: "content \u4E0D\u80FD\u4E3A\u7A7A" }],
-            isError: true
-          };
-        }
-        try {
-          await appendMessageContent(cfg, messageId, content);
-          console.log(`[apm] append_message \u5DF2\u8FFD\u52A0: messageId=${messageId}`);
-          return "\u5DF2\u8FFD\u52A0\u6D88\u606F\u5185\u5BB9";
-        } catch (err) {
-          const detail = err instanceof Error ? err.message : String(err);
-          return {
-            content: [{ type: "text", text: `\u8FFD\u52A0\u6D88\u606F\u5931\u8D25: ${detail}` }],
-            isError: true
-          };
-        }
-      }
-    }
-  };
-}
-
-// src/commands/connect/ask-question-tool.ts
-import { randomUUID } from "crypto";
-function createAskQuestionTool(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",
-          description: "Optional title for the questions form"
-        },
-        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 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:
-${payload}`);
-      options?.onInvoke?.(args);
-      return `[mock] AskQuestion \u5DF2\u8BB0\u5F55\uFF08\u672A\u521B\u5EFA\u4EFB\u52A1\u95EE\u9898\u3001\u672A\u7B49\u5F85\u7528\u6237\u56DE\u7B54\uFF09\u3002\u53C2\u6570:
-${payload}`;
-    }
-  };
-}
-
-// src/commands/connect/cursor-custom-tools.ts
-var PLAN_MODE_ASK_QUESTION_HINT = `[SDK \u73AF\u5883\u8BF4\u660E]
-AskQuestion \u5DF2\u901A\u8FC7 MCP \u670D\u52A1\u5668 custom-user-tools \u6CE8\u518C\uFF0C\u5DE5\u5177\u540D\u4E3A AskQuestion\u3002
-\u9700\u8981\u5411\u7528\u6237\u786E\u8BA4\u65F6\uFF0C\u8BF7\u8C03\u7528 AskQuestion\uFF08\u7ECF CallMcpTool / custom-user-tools\uFF09\uFF0C\u4E0D\u8981\u5047\u8BBE IDE \u5185\u7F6E AskQuestion \u4E0D\u53EF\u7528\u3002
-\u975E\u5FC5\u987B\u7684\u95EE\u9898\u53EF\u8DF3\u8FC7\uFF0C\u76F4\u63A5\u5B8C\u6210 createPlan\u3002`;
-function createCursorCustomTools(cfg, messageId, options) {
-  return {
-    ...createAppendMessageCustomTools(cfg, messageId),
-    AskQuestion: createAskQuestionMockTool({
-      onInvoke: options?.onAskQuestion
-    })
-  };
-}
-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;
-  }
-  return `${prompt.trim()}
-
-${PLAN_MODE_ASK_QUESTION_HINT}`;
-}
-
 // src/commands/connect/cursor-agent.ts
 setMaxListeners2(50);
-installAbortSignalDebug();
 var noopRemoteLogSync = {
   schedule(_session) {
   },
   async flush(_session) {
   }
 };
-var logCtx = (ctx, agentId) => ({
-  sessionId: ctx.sessionId,
-  messageId: ctx.messageId,
-  agentId
-});
-function formatCursorRunFailure(runId, options) {
-  const details = [
-    options?.statusError?.trim(),
-    options?.resultText?.trim()
-  ].filter((value, index, arr) => {
-    if (!value) return false;
-    return arr.indexOf(value) === index;
-  });
-  if (details.length === 0) {
-    return `Cursor run \u5931\u8D25: ${runId}`;
-  }
-  return `Cursor run \u5931\u8D25: ${runId} \u2014 ${details.join("\uFF1B")}`;
+function collectAssistantText(events) {
+  return events.flatMap((event) => {
+    if (event.type !== "assistant") return [];
+    const text = "text" in event ? String(event.text ?? "") : "";
+    return text ? [text] : [];
+  }).join("");
 }
 async function obtainAgent(ctx) {
   const agentOptions = {
     apiKey: ctx.apiKey,
     model: { id: ctx.model || "default" },
     local: {
-      cwd: ctx.cwd,
+      cwd: ctx.workdir,
       ...ctx.customTools ? { customTools: ctx.customTools } : {}
-    },
-    ...ctx.mode ? { mode: ctx.mode } : {}
-    // mcpServers: createPlaywrightMcpServers(),
+    }
   };
-  const explicitAgentId = ctx.resumeAgentId?.trim();
-  const savedAgentId = explicitAgentId || (ctx.user ? loadSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user) : void 0);
+  const savedAgentId = ctx.user ? loadTaskAgentId(ctx.workdir, ctx.taskId, ctx.user) : void 0;
   if (savedAgentId) {
     try {
       const agent2 = await Agent.resume(savedAgentId, agentOptions);
-      console.log(
-        `[apm] \u590D\u7528 Agent user=${ctx.user} agentId=${savedAgentId}${explicitAgentId ? "\uFF08\u53C2\u6570\u6307\u5B9A\uFF09" : ""}`
-      );
+      console.log(`[apm] \u590D\u7528 Agent user=${ctx.user} agentId=${savedAgentId}`);
       if (ctx.user) {
-        saveSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user, agent2.agentId);
+        saveTaskAgentId(ctx.workdir, ctx.taskId, ctx.user, agent2.agentId);
       }
       return { agent: agent2, resumed: true };
     } catch (err) {
@@ -3115,14 +1844,17 @@ async function obtainAgent(ctx) {
         `[apm] \u590D\u7528 Agent \u5931\u8D25\uFF08agentId=${savedAgentId}\uFF09\uFF0C\u56DE\u9000\u4E3A\u65B0\u5EFA:`,
         err instanceof Error ? err.message : err
       );
-      if (!explicitAgentId && ctx.user) {
-        clearSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user);
+      if (ctx.user) {
+        clearTaskAgentId(ctx.workdir, ctx.taskId, ctx.user);
       }
     }
   }
-  const agent = await Agent.create(agentOptions);
+  const agent = await Agent.create({
+    ...agentOptions,
+    ...ctx.mode ? { mode: ctx.mode } : {}
+  });
   if (ctx.user) {
-    saveSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user, agent.agentId);
+    saveTaskAgentId(ctx.workdir, ctx.taskId, ctx.user, agent.agentId);
   }
   return { agent, resumed: false };
 }
@@ -3134,34 +1866,38 @@ async function runCursorAgent(cfg, ctx, options) {
   }
   const apiKey = ctx.apiKey.trim();
   if (!apiKey) {
-    throw new Error("\u7F3A\u5C11 apiKey\uFF0C\u65E0\u6CD5\u8C03\u7528 Cursor SDK");
+    throw new Error("\u7F3A\u5C11 Cursor API Key");
   }
-  const workdir = resolveWorkdirPath(ctx.workdir);
-  const customTools = options?.customTools ?? createCursorCustomTools(cfg, ctx.messageId, {
-    onAskQuestion: options?.onAskQuestion
-  });
-  const prompt = withPlanModeToolHint(ctx.prompt, ctx.mode);
+  const workdir = requireExistingWorkdir(ctx.workdir);
+  const customTools = options?.customTools ?? {};
+  const prompt = `${ctx.prompt.trim()}
+
+---
+\u8BF7\u5B8C\u6210\u4E0A\u8FF0\u4EFB\u52A1\u3002\u6267\u884C\u8FC7\u7A0B\u4E2D\u8BF7\u7528 append_mail_reply \u589E\u91CF\u66F4\u65B0\u7ED9\u53D1\u4FE1\u4EBA\u7684\u56DE\u590D\uFF08\u53EF\u5148\u7B80\u77ED\u786E\u8BA4\uFF0C\u6709\u8FDB\u5C55\u7EE7\u7EED\u8FFD\u52A0\uFF09\uFF1BAgent \u6B63\u5E38\u7ED3\u675F\u540E\u4F1A\u81EA\u52A8\u63D0\u4EA4\u5B8C\u6574\u56DE\u4FE1\u3002\u5982\u9700\u7F16\u5199\u6587\u6863\uFF0C\u4FDD\u5B58\u5230 \`.apm/tasks/${ctx.taskId}/docs/\` \u76EE\u5F55\u3002`;
+  const mode = ctx.mode ?? "agent";
   console.log(
-    `[apm] Cursor Agent \u5F00\u59CB messageId=${ctx.messageId} sessionId=${ctx.sessionId} cwd=${workdir}`
+    `[apm] Cursor Agent \u5F00\u59CB mailId=${ctx.mailId} taskId=${ctx.taskId} mode=${mode} cwd=${workdir}`
   );
   const { agent, resumed } = await obtainAgent({
     apiKey,
     model: ctx.model,
-    cwd: workdir,
     workdir,
-    sessionId: ctx.sessionId,
+    taskId: ctx.taskId,
     user: ctx.user,
-    mode: ctx.mode,
-    resumeAgentId: ctx.resumeAgentId,
+    mode,
     customTools
   });
   const eventSession = new EventSession(prompt);
-  const syncRemoteLog = options?.skipRemoteLogSync ? noopRemoteLogSync : createThrottledCursorMessageLogSync(
+  const syncRemoteLog = options?.skipRemoteLogSync ? noopRemoteLogSync : createThrottledCursorLogSync(
     cfg,
-    logCtx(ctx, agent.agentId),
+    {
+      taskId: ctx.taskId,
+      mailboxMessageId: ctx.mailId,
+      agentId: agent.agentId
+    },
     (err) => {
       console.warn(
-        "[apm] \u540C\u6B65 Cursor \u6D88\u606F\u65E5\u5FD7\u5931\u8D25:",
+        `[apm] Cursor \u65E5\u5FD7\u540C\u6B65\u5931\u8D25 mailId=${ctx.mailId}:`,
         err instanceof Error ? err.message : err
       );
     }
@@ -3172,85 +1908,54 @@ async function runCursorAgent(cfg, ctx, options) {
     void activeRun.cancel().catch(() => void 0);
   };
   signal?.addEventListener("abort", abortRun, { once: true });
-  logAbortSignalStats(signal, "runCursorAgent:after-addListener");
+  const streamEvents = [];
   try {
+    const forceSend = options?.forceSend ?? resumed;
     const run = await agent.send(prompt, {
-      ...ctx.mode ? { mode: ctx.mode } : {},
-      // mcpServers: createPlaywrightMcpServers(),
+      mode,
       local: {
-        ...options?.forceSend ? { force: true } : {},
-        customTools
+        customTools,
+        ...forceSend ? { force: true } : {}
       }
     });
     activeRun = run;
-    logAbortSignalStats(signal, "runCursorAgent:after-send");
     console.log(`[apm] Cursor run id=${run.id} agentId=${agent.agentId}`);
-    let lastRunErrorStatus;
     for await (const event of run.stream()) {
       if (signal?.aborted) {
         abortRun();
         throw new Error("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u4EFB\u52A1\u4E2D\u65AD");
       }
-      if (event.type === "status" && event.status === "ERROR") {
-        const message = event.message?.trim();
-        if (message) {
-          lastRunErrorStatus = message;
-          console.error(
-            `[apm] Cursor run status=ERROR runId=${run.id}: ${message}`
-          );
-        }
-      }
-      options?.onStreamEvent?.(event);
+      streamEvents.push(event);
       eventSession.addEvent(event);
       syncRemoteLog.schedule(eventSession);
     }
     await syncRemoteLog.flush(eventSession);
     const result = await run.wait();
+    const assistantText = eventSession.getAssistantText() || collectAssistantText(streamEvents);
+    const createPlanContent = eventSession.getCreatePlanContent() || collectCreatePlanContent(streamEvents);
     if (result.status === "error") {
-      const failureMessage = formatCursorRunFailure(result.id, {
-        statusError: lastRunErrorStatus,
-        resultText: result.result
-      });
-      console.error(`[apm] ${failureMessage}`);
       if (resumed) {
-        clearSessionAgentId(workdir, ctx.sessionId, ctx.user);
+        clearTaskAgentId(workdir, ctx.taskId, ctx.user);
       }
-      throw new Error(failureMessage);
+      throw new Error(
+        `Cursor run \u5931\u8D25: ${result.id}${result.result ? ` \u2014 ${result.result}` : ""}`
+      );
     }
     if (result.status === "cancelled") {
       throw new Error(`Cursor run \u5DF2\u53D6\u6D88: ${result.id}`);
     }
-    console.log(`[apm] Cursor Agent \u5B8C\u6210 messageId=${ctx.messageId}`);
-    const artifacts = await agent.listArtifacts().catch(() => []);
-    const artifactDocuments = [];
-    for (const artifact of artifacts) {
-      try {
-        const content = (await agent.downloadArtifact(artifact.path)).toString(
-          "utf8"
-        );
-        artifactDocuments.push({ path: artifact.path, content });
-      } catch (err) {
-        console.warn(
-          `[apm] \u8BFB\u53D6\u4EA7\u7269\u5931\u8D25 path=${artifact.path}:`,
-          err instanceof Error ? err.message : err
-        );
-      }
-    }
+    console.log(`[apm] Cursor Agent \u5B8C\u6210 mailId=${ctx.mailId}`);
     return {
       runId: result.id,
       agentId: agent.agentId,
       status: result.status,
-      result: result.result,
-      durationMs: result.durationMs,
-      assistantText: eventSession.getAssistantText(),
-      createPlan: eventSession.getCreatePlanContent(),
-      artifacts,
-      artifactDocuments
+      assistantText: assistantText || result.result || "",
+      ...createPlanContent ? { createPlanContent } : {}
     };
   } catch (err) {
     if (err instanceof CursorAgentError) {
       if (resumed) {
-        clearSessionAgentId(workdir, ctx.sessionId, ctx.user);
+        clearTaskAgentId(workdir, ctx.taskId, ctx.user);
       }
       throw new Error(
         `Cursor \u542F\u52A8\u5931\u8D25: ${err.message}${err.isRetryable ? "\uFF08\u53EF\u91CD\u8BD5\uFF09" : ""}`
@@ -3258,338 +1963,442 @@ async function runCursorAgent(cfg, ctx, options) {
     }
     throw err;
   } finally {
-    logAbortSignalStats(signal, "runCursorAgent:finally-before-cleanup");
     signal?.removeEventListener("abort", abortRun);
-    logAbortSignalStats(signal, "runCursorAgent:finally-after-cleanup");
     await agent[Symbol.asyncDispose]();
   }
 }
 
-// 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
+// src/commands/connect/mail-store.ts
+var pendingMails = [];
+var seenMailIds = /* @__PURE__ */ new Set();
+var repliedMailIds = /* @__PURE__ */ new Set();
+function hasMailReplied(mailId) {
+  return repliedMailIds.has(mailId);
+}
+function markMailReplied(mailId) {
+  repliedMailIds.add(mailId);
+  seenMailIds.add(mailId);
+  removeMailById(mailId);
+}
+function enqueueReceivedMail(mail) {
+  if (seenMailIds.has(mail.id)) {
+    return false;
+  }
+  seenMailIds.add(mail.id);
+  pendingMails.push(mail);
+  console.log(
+    `[apm] \u6536\u5230\u4FE1\u4EF6 id=${mail.id} taskId=${mail.taskId} createdAt=${mail.createdAt}`
+  );
+  return true;
+}
+function dequeueNextMail() {
+  return pendingMails.shift();
+}
+function hasPendingMail() {
+  return pendingMails.length > 0;
+}
+function removeMailById(mailId) {
+  const index = pendingMails.findIndex((mail) => mail.id === mailId);
+  if (index < 0) {
+    return false;
+  }
+  pendingMails.splice(index, 1);
+  return true;
+}
+
+// src/commands/connect/reply-mail-tool.ts
+function createMailReplyDraft() {
+  const parts = [];
+  const tool = {
+    description: "\u5411\u53D1\u4FE1\u4EBA\u589E\u91CF\u66F4\u65B0\u56DE\u590D\u5185\u5BB9\u3002\u53EF\u591A\u6B21\u8C03\u7528\u8FFD\u52A0\u8FDB\u5C55\uFF08\u5982\u5148\u786E\u8BA4\u6536\u5230\u3001\u518D\u6C47\u62A5\u7ED3\u679C\uFF09\uFF1BAgent \u6B63\u5E38\u7ED3\u675F\u540E\u4F1A\u81EA\u52A8\u63D0\u4EA4\u5B8C\u6574\u56DE\u4FE1\uFF0C\u65E0\u9700\u53E6\u884C\u6536\u5C3E\u3002",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "\u672C\u6B21\u8FFD\u52A0\u7684\u56DE\u590D\u7247\u6BB5"
+        }
       },
-      {
-        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
-        });
+      required: ["content"]
+    },
+    execute: async (args) => {
+      const content = typeof args.content === "string" ? args.content.trim() : "";
+      if (!content) {
+        return {
+          content: [{ type: "text", text: "content \u4E0D\u80FD\u4E3A\u7A7A" }],
+          isError: true
+        };
       }
-      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
-      });
+      parts.push(content);
+      console.log(`[apm] \u589E\u91CF\u66F4\u65B0\u56DE\u4FE1\uFF08\u7B2C ${parts.length} \u6BB5\uFF09`);
+      return "\u5DF2\u8FFD\u52A0\u5230\u56DE\u4FE1\u8349\u7A3F\uFF0CAgent \u7ED3\u675F\u540E\u5C06\u4E00\u5E76\u63D0\u4EA4\u3002";
     }
-  }
+  };
+  return {
+    tool,
+    getReplyContent: () => parts.join("\n\n"),
+    hasReplyContent: () => parts.some((part) => part.trim().length > 0)
+  };
 }
 
-// src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync11 } 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)) {
-    return null;
+// src/commands/connect/task-pull.ts
+import { writeFileSync as writeFileSync10 } from "fs";
+import { join as join13 } from "path";
+import { stringify as yamlStringify } from "yaml";
+
+// src/rules-sync.ts
+import { basename as basename2, extname, join as join12 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync9, rmSync as rmSync3, writeFileSync as writeFileSync9 } from "fs";
+var MANIFEST_FILE2 = ".rules-sync-manifest.json";
+function ruleLocalFileName(ruleName) {
+  const trimmed = ruleName.trim();
+  if (!trimmed) return "rule.md";
+  const sanitized = trimmed.replace(/[/\\:*?"<>|]/g, "_");
+  if (extname(sanitized).toLowerCase() === ".md") return sanitized;
+  return `${sanitized}.md`;
+}
+function loadManifest(rulesDir) {
+  const path10 = join12(rulesDir, MANIFEST_FILE2);
+  if (!existsSync8(toFsPath(path10))) {
+    return { version: 1, rules: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync11(path10, "utf8")
+      readFileSync9(toFsPath(path10), "utf8")
     );
-    if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
+    if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
       return parsed;
     }
   } catch {
   }
-  return null;
+  return { version: 1, rules: {} };
 }
-function saveManifest3(apmDir, cliVersion) {
-  const manifest = { version: 1, cliVersion };
-  writeFileSync11(
-    toFsPath(manifestPath(apmDir)),
+function saveManifest(rulesDir, manifest) {
+  writeFileSync9(
+    toFsPath(join12(rulesDir, MANIFEST_FILE2)),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
-var syncedInSession = /* @__PURE__ */ new Map();
-function shouldSyncSkillsForCliVersion(workdir, currentVersion) {
-  const cached = syncedInSession.get(workdir);
-  if (cached === currentVersion) {
-    return false;
-  }
-  const stored = loadManifest3(workspaceApmDir(workdir));
-  if (stored?.cliVersion === currentVersion) {
-    syncedInSession.set(workdir, currentVersion);
-    return false;
-  }
-  return true;
+function isBaseRuleFileName(fileName) {
+  return listBaseRuleFileNames().includes(basename2(fileName));
 }
-function markSkillsSyncedForCliVersion(workdir, cliVersion) {
-  saveManifest3(workspaceApmDir(workdir), cliVersion);
-  syncedInSession.set(workdir, cliVersion);
+function isRuleUpToDate(entry, rule, dest) {
+  if (!entry || !existsSync8(toFsPath(dest))) return false;
+  if (entry.fileName !== ruleLocalFileName(rule.name)) return false;
+  const updatedAt = rule.updatedAt ?? "";
+  if (entry.updatedAt !== updatedAt) return false;
+  const localContent = readFileSync9(toFsPath(dest), "utf8");
+  return localContent === (rule.content ?? "");
 }
-
-// src/commands/connect/pre-step-cache.ts
-var PULL_TTL_MS = 3e4;
-function sessionWorkdirKey(sessionId, workdir) {
-  return `${sessionId}\0${workdir}`;
-}
-var lastBranchKey = null;
-var lastPullAtByKey = /* @__PURE__ */ new Map();
-function shouldRunBranch(sessionId, workdir) {
-  return lastBranchKey !== sessionWorkdirKey(sessionId, workdir);
-}
-function markBranchDone(sessionId, workdir) {
-  lastBranchKey = sessionWorkdirKey(sessionId, workdir);
-}
-function shouldRunPull(sessionId, workdir) {
-  const key = sessionWorkdirKey(sessionId, workdir);
-  const last = lastPullAtByKey.get(key);
-  if (last == null) {
-    return true;
+async function syncPlatformRules(cfg, workdirPath, apmRoot) {
+  const api = createApmApiClient(cfg);
+  const baseline = await api.cli.workspaceBaseline({ workdirPath });
+  const repositoryId = baseline.repositoryId;
+  const rulesDir = join12(apmRoot ?? workspaceApmDir(workdirPath), "rules");
+  await ensureDirExists(rulesDir);
+  if (!repositoryId) {
+    console.log(
+      `[apm] \u672A\u5339\u914D\u5230\u7ED1\u5B9A\u4ED3\u5E93\u7684\u5DE5\u4F5C\u7A7A\u95F4\uFF0C\u8DF3\u8FC7\u5E73\u53F0\u89C4\u5219\u540C\u6B65\uFF08\u8DEF\u5F84\uFF1A${workdirPath}\uFF09`
+    );
+    return { written: [], skipped: [], removed: [], repositoryId: null };
   }
-  return Date.now() - last >= PULL_TTL_MS;
-}
-function markPullDone(sessionId, workdir) {
-  lastPullAtByKey.set(sessionWorkdirKey(sessionId, workdir), Date.now());
-}
-
-// src/commands/connect/run-slot-pool.ts
-var DEFAULT_MAX_CONCURRENT = 5;
-function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT) {
-  let active = 0;
-  const waiters = [];
-  const acquire = () => {
-    if (active < maxConcurrent) {
-      active += 1;
-      return Promise.resolve();
+  const { list } = await api.cli.listRules({ repositoryId });
+  const manifest = loadManifest(rulesDir);
+  const nextManifest = { version: 1, rules: {} };
+  const remoteIds = /* @__PURE__ */ new Set();
+  const written = [];
+  const skipped = [];
+  for (const rule of list) {
+    remoteIds.add(rule.id);
+    const fileName = ruleLocalFileName(rule.name);
+    const dest = join12(rulesDir, fileName);
+    const entry = manifest.rules[rule.id];
+    const updatedAt = rule.updatedAt ?? "";
+    if (isRuleUpToDate(entry, rule, dest)) {
+      nextManifest.rules[rule.id] = entry;
+      skipped.push(fileName);
+      console.log(`[apm] \u89C4\u5219\u65E0\u53D8\u5316\uFF0C\u5DF2\u8DF3\u8FC7: rules/${fileName}`);
+      continue;
     }
-    return new Promise((resolve5) => {
-      waiters.push(() => {
-        active += 1;
-        resolve5();
-      });
-    });
-  };
-  const release = () => {
-    active = Math.max(0, active - 1);
-    const next = waiters.shift();
-    if (next) {
-      next();
+    writeFileSync9(toFsPath(dest), rule.content ?? "", "utf8");
+    nextManifest.rules[rule.id] = { fileName, updatedAt };
+    written.push(fileName);
+    console.log(`[apm] \u5DF2\u540C\u6B65\u5E73\u53F0\u89C4\u5219: rules/${fileName}`);
+  }
+  const removed = [];
+  for (const [ruleId, entry] of Object.entries(manifest.rules)) {
+    if (remoteIds.has(ruleId)) continue;
+    if (isBaseRuleFileName(entry.fileName)) continue;
+    const dest = join12(rulesDir, entry.fileName);
+    if (existsSync8(toFsPath(dest))) {
+      rmSync3(toFsPath(dest), { force: true });
     }
-  };
-  return { acquire, release };
+    removed.push(entry.fileName);
+    console.log(`[apm] \u5DF2\u79FB\u9664\u5DF2\u4E0B\u7EBF\u7684\u5E73\u53F0\u89C4\u5219: rules/${entry.fileName}`);
+  }
+  saveManifest(rulesDir, nextManifest);
+  return { written, skipped, removed, repositoryId };
 }
 
-// src/commands/connect.ts
-var HEARTBEAT_MS = 3e4;
-async function updateMessageStatus(cfg, messageId, status) {
-  const api = createApmApiClient(cfg);
-  await api.cli.updateMessageStatus({ id: messageId, status });
-  console.log(`[apm] \u5DF2\u66F4\u65B0\u6D88\u606F\u72B6\u6001: ${messageId} \u2192 ${status}`);
-}
-async function setMessageError(cfg, messageId, error) {
-  const api = createApmApiClient(cfg);
-  await api.cli.setMessageError({ id: messageId, error });
-  console.log(`[apm] \u5DF2\u8BBE\u7F6E\u6D88\u606F\u9519\u8BEF: ${messageId}`);
+// src/commands/connect/task-pull.ts
+async function runTaskPull(cfg, detail) {
+  const { taskId, workdir } = detail;
+  assertWorkspaceApmDirExists(workdir);
+  const apmRoot = workspaceApmDir(workdir);
+  const dir = taskDir(taskId, apmRoot, workdir);
+  const docsDir = taskDocsDir(taskId, apmRoot, workdir);
+  await ensureDirExists(docsDir);
+  writeFileSync10(taskRulePath(taskId, apmRoot, workdir), "", "utf8");
+  writeFileSync10(
+    taskTaskPath(taskId, apmRoot, workdir),
+    detail.task.description ?? "",
+    "utf8"
+  );
+  for (const doc of detail.documents) {
+    const fileName = documentLocalFileName(doc.name);
+    writeFileSync10(join13(docsDir, fileName), doc.content ?? "", "utf8");
+  }
+  const members = detail.studio?.members ?? [];
+  const taskYaml = yamlStringify(
+    {
+      name: detail.studio?.title ?? detail.task.title,
+      phase: detail.studio?.phase ?? null,
+      task: "./TASK.md",
+      members: members.map((member) => ({
+        name: member.displayName,
+        oxcAgent: member.oxcAgent?.name ?? "",
+        description: member.oxcAgent?.description ?? "",
+        isLead: member.isLead
+      })),
+      attachments: detail.attachments.map((item) => ({ name: item.name }))
+    },
+    { lineWidth: 0 }
+  );
+  writeFileSync10(
+    taskYamlPath(taskId, apmRoot, workdir),
+    taskYaml.endsWith("\n") ? taskYaml : `${taskYaml}
+`,
+    "utf8"
+  );
+  await syncPlatformRules(cfg, workdir, apmRoot);
+  await syncRemoteDeploymentConfig(workdir, apmRoot);
+  await syncRepositoryProjectDocumentsPull(workdir, apmRoot);
+  console.log(`[apm] \u5DF2\u540C\u6B65\u4EFB\u52A1\u5DE5\u4F5C\u533A: ${toFsPath(dir)}`);
+  return dir;
 }
-var SHUTDOWN_DRAIN_MS = 3e3;
-function isUserCancelled(ctx) {
-  return ctx.perMessageSignal.aborted && !ctx.shutdownSignal.aborted;
+
+// src/commands/connect/mail-processor.ts
+function resolveCursorAgentMode(phase) {
+  return phase === "PLANNING" ? "plan" : "agent";
 }
-async function handleInboundMessage(cfg, msg, signal, ctx) {
-  if (isUserCancelled(ctx)) return;
-  if (signal.aborted) return;
-  const messageId = msg.messageId;
-  const workdir = requireRemoteWorkdir(msg.workdir);
-  const apmRoot = workspaceApmDir(workdir);
-  const runStep = async (step, fn) => {
-    const startedAt = Date.now();
-    try {
-      const result = await fn();
-      console.log(`[apm] step=${step} elapsed=${Date.now() - startedAt}ms`);
-      return result;
-    } catch (err) {
-      const detail = err instanceof Error ? err.message : String(err);
-      throw new Error(`[${step}] ${detail}`);
-    }
-  };
+async function processMail(mail, options) {
+  const api = createApmApiClient(options.cfg);
+  console.log(`[apm] \u5F00\u59CB\u5904\u7406\u4FE1\u4EF6 id=${mail.id}`);
+  if (hasMailReplied(mail.id)) {
+    console.log(`[apm] \u4FE1\u4EF6 id=${mail.id} \u5DF2\u56DE\u590D\u8FC7\uFF0C\u8DF3\u8FC7`);
+    return;
+  }
+  const cursorApiKey = options.getCursorApiKey().trim();
+  if (!cursorApiKey) {
+    options.onFatalError(
+      "[apm] \u5BA2\u6237\u673A\u672A\u914D\u7F6E Cursor API Key\uFF0C\u65E0\u6CD5\u5904\u7406\u4FE1\u4EF6\uFF0C\u65AD\u5F00\u8FDE\u63A5"
+    );
+    return;
+  }
+  let detail;
   try {
-    if (signal.aborted) return;
-    const { didInit } = await runStep(
-      "workspace-init",
-      () => ensureWorkspaceInitialized(workdir)
+    detail = await api.cli.getMailboxMessageDetail({ id: mail.id });
+  } catch (err) {
+    console.error(
+      `[apm] \u83B7\u53D6\u4FE1\u4EF6\u8BE6\u60C5\u5931\u8D25 id=${mail.id}:`,
+      err instanceof Error ? err.message : err
     );
-    if (!didInit) {
-      assertApmGitignoredInRepo(workdir);
-    }
-    await runStep(
-      "status-typing",
-      () => updateMessageStatus(cfg, messageId, "TYPING")
+    return;
+  }
+  try {
+    await runTaskPull(options.cfg, detail);
+  } catch (err) {
+    console.error(
+      `[apm] \u540C\u6B65\u4EFB\u52A1\u5DE5\u4F5C\u533A\u5931\u8D25 taskId=${detail.taskId}:`,
+      err instanceof Error ? err.message : err
     );
-    if (shouldRunBranch(msg.sessionId, workdir)) {
-      if (signal.aborted) return;
-      await runStep("branch", () => runBranch(msg.sessionId, { cwd: workdir }));
-      markBranchDone(msg.sessionId, workdir);
-    } else {
-      console.log(`[apm] step=branch skipped sessionId=${msg.sessionId}`);
-    }
-    let pullRan = false;
-    if (shouldRunPull(msg.sessionId, workdir)) {
-      if (signal.aborted) return;
-      await runStep("pull", () => runPull(msg.sessionId, workdir));
-      markPullDone(msg.sessionId, workdir);
-      pullRan = true;
-    } else {
-      console.log(`[apm] step=pull skipped sessionId=${msg.sessionId}`);
-    }
-    if (pullRan) {
-      if (signal.aborted) return;
-      await runStep(
-        "commit-pull",
-        () => commitWorkingTreeIfDirty(workdir, "fix: apm pull")
-      );
-    } else {
-      console.log(`[apm] step=commit-pull skipped sessionId=${msg.sessionId}`);
-    }
-    const cliVersion = readCliVersion();
-    if (shouldSyncSkillsForCliVersion(workdir, cliVersion)) {
-      if (signal.aborted) return;
-      console.log(
-        `[apm] CLI \u7248\u672C ${cliVersion} \u4E0E\u5DE5\u4F5C\u533A\u8BB0\u5F55\u4E0D\u4E00\u81F4\uFF0C\u6267\u884C update-skills`
-      );
-      await runStep("update-skills", async () => {
-        await syncWorkspaceSkills(cfg, workdir);
-        markSkillsSyncedForCliVersion(workdir, cliVersion);
-      });
-    } else {
-      console.log(`[apm] step=update-skills skipped workdir=${workdir}`);
-    }
-    if (signal.aborted) return;
-    if (!pullRan) {
-      await runStep(
-        "sync-project-documents-pull",
-        () => syncRepositoryProjectDocumentsPull(workdir, apmRoot)
-      );
+    return;
+  }
+  if (detail.status !== "PENDING") {
+    console.log(`[apm] \u4FE1\u4EF6 id=${mail.id} \u72B6\u6001\u4E3A ${detail.status}\uFF0C\u8DF3\u8FC7\u5904\u7406`);
+    if (detail.status === "SUCCEEDED" || detail.status === "FAILED") {
+      markMailReplied(mail.id);
     }
-    await runStep(
-      "cursor-agent",
-      () => runCursorAgent(
-        cfg,
-        {
-          messageId: msg.messageId,
-          sessionId: msg.sessionId,
-          prompt: msg.content,
-          model: msg.model,
-          apiKey: msg.apiKey,
-          workdir,
-          user: msg.user
-        },
-        { signal }
-      )
-    );
-    await runStep(
-      "sync-documents",
-      () => syncSessionDocuments(cfg, msg.sessionId, apmRoot)
-    );
-    await runStep(
-      "sync-project-documents",
-      () => syncRepositoryProjectDocumentsPush(cfg, workdir, apmRoot)
-    );
-    await runStep(
-      "commit-files",
-      () => commitWorkingTreeIfDirty(workdir, "chore(apm): commit working tree")
-    );
-    await runStep(
-      "status-success",
-      () => updateMessageStatus(cfg, messageId, "SUCCESS")
-    );
+    return;
+  }
+  try {
+    await api.cli.claimMailboxMessage({ id: mail.id });
   } catch (err) {
-    if (isUserCancelled(ctx)) {
-      console.log(`[apm] \u6D88\u606F\u5DF2\u7EC8\u6B62 messageId=${messageId}`);
-      return;
-    }
     console.error(
-      "[apm] \u5904\u7406\u6D88\u606F\u5931\u8D25:",
-      err instanceof Error ? err.message : String(err)
+      `[apm] \u8BA4\u9886\u4FE1\u4EF6\u5931\u8D25 id=${mail.id}:`,
+      err instanceof Error ? err.message : err
+    );
+    return;
+  }
+  removeMailById(mail.id);
+  const {
+    tool: replyTool,
+    getReplyContent,
+    hasReplyContent
+  } = createMailReplyDraft();
+  try {
+    const cursorMode = resolveCursorAgentMode(detail.studio?.phase);
+    const result = await runCursorAgent(
+      options.cfg,
+      {
+        mailId: detail.id,
+        taskId: detail.taskId,
+        prompt: detail.content,
+        model: detail.recipient.model?.trim() || "default",
+        apiKey: cursorApiKey,
+        workdir: detail.workdir,
+        user: detail.recipient.displayName,
+        mode: cursorMode
+      },
+      {
+        signal: options.signal,
+        customTools: { append_mail_reply: replyTool }
+      }
     );
-    if (err instanceof Error && err.stack) {
-      console.error(err.stack);
+    const replyContent = (hasReplyContent() ? getReplyContent() : result.assistantText).trim();
+    if (!replyContent) {
+      throw new Error("Agent \u672A\u4EA7\u51FA\u53EF\u63D0\u4EA4\u7684\u56DE\u4FE1\u5185\u5BB9");
+    }
+    if (cursorMode === "plan" && result.createPlanContent) {
+      saveMemberPlanDocument({
+        workdir: detail.workdir,
+        taskId: detail.taskId,
+        memberDisplayName: detail.recipient.displayName,
+        content: result.createPlanContent
+      });
     }
+    await api.cli.completeMailboxMessage({
+      id: detail.id,
+      status: "SUCCEEDED",
+      replyContent
+    });
+    markMailReplied(detail.id);
+    await syncTaskDocuments(options.cfg, detail.taskId, detail.workdir, {
+      api,
+      remoteDocuments: detail.documents
+    });
+    console.log(`[apm] \u4FE1\u4EF6\u5904\u7406\u5B8C\u6210 id=${mail.id}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[apm] \u4FE1\u4EF6\u5904\u7406\u5931\u8D25 id=${mail.id}: ${message}`);
     try {
-      await setMessageError(
-        cfg,
-        messageId,
-        err instanceof Error ? err.message : String(err)
-      );
-      await updateMessageStatus(cfg, messageId, "FAILED");
-    } catch (statusErr) {
+      await api.cli.completeMailboxMessage({
+        id: detail.id,
+        status: "FAILED",
+        error: message
+      });
+    } catch (completeErr) {
       console.error(
-        "[apm] \u66F4\u65B0 FAILED \u72B6\u6001\u5931\u8D25:",
-        statusErr instanceof Error ? statusErr.message : statusErr
+        `[apm] \u6807\u8BB0\u4FE1\u4EF6\u5931\u8D25\u72B6\u6001\u65F6\u51FA\u9519 id=${mail.id}:`,
+        completeErr instanceof Error ? completeErr.message : completeErr
       );
     }
+    markMailReplied(detail.id);
+  }
+}
+function createMailProcessor(options) {
+  let running = false;
+  const pump = () => {
+    if (running || options.signal.aborted) {
+      return;
+    }
+    running = true;
+    void (async () => {
+      try {
+        while (!options.signal.aborted) {
+          const mail = dequeueNextMail();
+          if (!mail) {
+            break;
+          }
+          await processMail(mail, options);
+        }
+      } finally {
+        running = false;
+        if (hasPendingMail() && !options.signal.aborted) {
+          pump();
+        }
+      }
+    })();
+  };
+  const ingest = (mail) => {
+    if (enqueueReceivedMail(mail)) {
+      pump();
+    }
+  };
+  return {
+    receive(msg) {
+      ingest({
+        id: msg.id,
+        taskId: msg.taskId,
+        createdAt: msg.createdAt
+      });
+    },
+    syncPendingMails(mails) {
+      let added = 0;
+      for (const mail of mails) {
+        if (enqueueReceivedMail(mail)) {
+          added++;
+        }
+      }
+      if (added > 0) {
+        console.log(`[apm] \u540C\u6B65\u5F85\u5904\u7406\u4FE1\u4EF6 ${added} \u5C01`);
+      } else if (mails.length > 0) {
+        console.log(
+          `[apm] \u540C\u6B65\u5F85\u5904\u7406\u4FE1\u4EF6 0 \u5C01\uFF08${mails.length} \u5C01\u5DF2\u5728\u961F\u5217\u4E2D\uFF09`
+        );
+      } else {
+        console.log("[apm] \u540C\u6B65\u5F85\u5904\u7406\u4FE1\u4EF6 0 \u5C01");
+      }
+      pump();
+    }
+  };
+}
+
+// src/commands/connect/mail-sync.ts
+function parsePendingMail(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const row = value;
+  if (typeof row.id !== "string" || typeof row.taskId !== "string") {
+    return null;
+  }
+  const createdAt = typeof row.createdAt === "string" ? row.createdAt : row.createdAt instanceof Date ? row.createdAt.toISOString() : "";
+  if (!createdAt) {
+    return null;
+  }
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    createdAt
+  };
+}
+async function fetchPendingMails(cfg) {
+  const api = createApmApiClient(cfg);
+  const list = await api.cli.listPendingMailboxMessages({});
+  if (!Array.isArray(list)) {
+    return [];
   }
+  return list.flatMap((item) => {
+    const mail = parsePendingMail(item);
+    return mail ? [mail] : [];
+  });
 }
+
+// src/commands/connect.ts
+var HEARTBEAT_MS = 3e4;
 function startHeartbeat(ws, clientMachineId) {
   const send = () => {
     if (ws.readyState === WebSocket.OPEN) {
@@ -3639,11 +2448,17 @@ async function runConnect(options) {
     let stopHeartbeat;
     let shuttingDown = false;
     const shutdownAbort = new AbortController();
-    const runSlots = createRunSlotPool();
-    const activeTasks = /* @__PURE__ */ new Set();
-    const activeRuns = /* @__PURE__ */ new Map();
-    const pendingCancels = /* @__PURE__ */ new Set();
-    const shutdown = async (code = 0) => {
+    let cursorApiKey = "";
+    const mailProcessor = createMailProcessor({
+      cfg,
+      signal: shutdownAbort.signal,
+      getCursorApiKey: () => cursorApiKey,
+      onFatalError: (message) => {
+        console.error(message);
+        shutdown(1);
+      }
+    });
+    const shutdown = (code = 0) => {
       if (shuttingDown) return;
       shuttingDown = true;
       logAbortSignalStats(
@@ -3656,19 +2471,34 @@ async function runConnect(options) {
       if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
         ws.terminate();
       }
-      try {
-        await Promise.race([
-          Promise.all(activeTasks),
-          new Promise((r) => setTimeout(r, SHUTDOWN_DRAIN_MS))
-        ]);
-      } catch {
-      }
       resolve5();
       process.exit(code);
     };
     ws.on("open", () => {
       console.log("[apm] WebSocket \u5DF2\u8FDE\u63A5");
       stopHeartbeat = startHeartbeat(ws, clientMachineId);
+      void (async () => {
+        try {
+          const api = createApmApiClient(cfg);
+          const me = await api.cli.me({});
+          cursorApiKey = me.cursorApiKey?.trim() ?? "";
+          if (!cursorApiKey) {
+            console.error(
+              "[apm] \u5BA2\u6237\u673A\u672A\u914D\u7F6E Cursor API Key\uFF0C\u8BF7\u5728\u5E73\u53F0\u5BA2\u6237\u673A\u8BBE\u7F6E\u4E2D\u914D\u7F6E\u540E\u91CD\u8BD5"
+            );
+            shutdown(1);
+            return;
+          }
+          const mails = await fetchPendingMails(cfg);
+          mailProcessor.syncPendingMails(mails);
+        } catch (err) {
+          console.error(
+            "[apm] \u8FDE\u63A5\u540E\u521D\u59CB\u5316\u5931\u8D25:",
+            err instanceof Error ? err.message : err
+          );
+          shutdown(1);
+        }
+      })();
     });
     ws.on("message", (data) => {
       if (shuttingDown) return;
@@ -3686,93 +2516,19 @@ async function runConnect(options) {
         console.error(`[apm] \u6536\u5230\u65E0\u6548 WS \u5305: ${validated.reason}`);
         return;
       }
-      if (validated.data.type === "cancel") {
-        const { messageId } = validated.data;
-        pendingCancels.add(messageId);
-        activeRuns.get(messageId)?.abort();
-        return;
-      }
       if (validated.data.type === "deploy") {
-        const msg2 = validated.data;
-        const perDeployController = new AbortController();
-        const signal2 = AbortSignal.any([
-          shutdownAbort.signal,
-          perDeployController.signal
-        ]);
-        const task2 = (async () => {
-          await runSlots.acquire();
-          try {
-            await handleInboundDeploy(cfg, msg2, signal2);
-          } finally {
-            runSlots.release();
-          }
-        })();
-        activeTasks.add(task2);
-        void task2.finally(() => {
-          activeTasks.delete(task2);
-        });
-        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);
-        });
+        void handleInboundDeploy(cfg, validated.data, shutdownAbort.signal);
         return;
       }
-      if (validated.data.type !== "message") {
-        return;
-      }
-      const msg = validated.data;
-      const perMessageController = new AbortController();
-      activeRuns.set(msg.messageId, perMessageController);
-      if (pendingCancels.has(msg.messageId)) {
-        activeRuns.delete(msg.messageId);
-        pendingCancels.delete(msg.messageId);
-        return;
+      if (validated.data.type === "received_mail") {
+        mailProcessor.receive(validated.data);
       }
-      const signal = AbortSignal.any([
-        shutdownAbort.signal,
-        perMessageController.signal
-      ]);
-      const ctx = {
-        shutdownSignal: shutdownAbort.signal,
-        perMessageSignal: perMessageController.signal
-      };
-      const task = (async () => {
-        await runSlots.acquire();
-        try {
-          await handleInboundMessage(cfg, msg, signal, ctx);
-        } finally {
-          runSlots.release();
-          activeRuns.delete(msg.messageId);
-          pendingCancels.delete(msg.messageId);
-        }
-      })();
-      activeTasks.add(task);
-      void task.finally(() => {
-        activeTasks.delete(task);
-      });
     });
     ws.on("close", (code, reason) => {
       console.log(
         `[apm] \u8FDE\u63A5\u5DF2\u65AD\u5F00 code=${code}${reason ? ` reason=${reason.toString()}` : ""}`
       );
-      void shutdown();
+      shutdown();
     });
     ws.on("error", (err) => {
       console.error("[apm] WebSocket \u9519\u8BEF:", err.message);
@@ -3780,55 +2536,31 @@ async function runConnect(options) {
     });
     process.on("SIGINT", () => {
       console.log("[apm] \u6B63\u5728\u5173\u95ED\u2026");
-      void shutdown();
+      shutdown();
     });
     process.on("SIGTERM", () => {
-      void shutdown();
+      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 { existsSync as existsSync9, readFileSync as readFileSync10 } 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)) {
+  if (!existsSync9(p)) {
     console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
     process.exit(1);
   }
   try {
-    const raw = readFileSync12(p, "utf8");
+    const raw = readFileSync10(p, "utf8");
     return JSON.parse(raw);
   } catch (e) {
     console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
@@ -3950,7 +2682,7 @@ import path4 from "node:path";
 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 { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
 import path from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
@@ -3962,8 +2694,8 @@ function asOptionalTlsBuffer(value) {
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync14(normalized)) {
-    return readFileSync13(normalized);
+  if (existsSync10(normalized)) {
+    return readFileSync11(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -4173,7 +2905,7 @@ 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 { existsSync as existsSync11, readFileSync as readFileSync12, statSync as statSync4 } from "node:fs";
 import path2 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
@@ -4190,10 +2922,10 @@ function loadEnvFromFile(envFilePath) {
     return {};
   }
   const targetPath = path2.resolve(envFilePath);
-  if (!existsSync15(targetPath) || !statSync5(targetPath).isFile()) {
+  if (!existsSync11(targetPath) || !statSync4(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync14(targetPath, "utf-8");
+  const raw = readFileSync12(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -4364,12 +3096,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import path3 from "node:path";
 function resolveDockerBuildPaths(cwd) {
   const dockerfilePath = path3.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
-  if (!existsSync16(dockerfilePath)) {
+  if (!existsSync12(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");
@@ -4498,14 +3230,14 @@ import { copyFile, readdir as readdir2, stat } from "node:fs/promises";
 import path7 from "node:path";
 
 // src/commands/deploy/internal/minio.ts
-import { statSync as statSync6 } from "node:fs";
+import { statSync as statSync5 } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import path6 from "node:path";
 import * as Minio from "minio";
 var DEFAULT_MAX_FILE_SIZE_MB = 50;
 async function isDirectoryPath(dir) {
   try {
-    const st = statSync6(dir);
+    const st = statSync5(dir);
     return st.isDirectory();
   } catch {
     return false;
@@ -4535,7 +3267,7 @@ async function collectFiles(root) {
       if (e.isDirectory()) {
         await walk(abs, rel);
       } else if (e.isFile()) {
-        const st = statSync6(abs);
+        const st = statSync5(abs);
         out.push({
           absPath: abs,
           relativePath: rel.replace(/\\/g, "/"),
@@ -4993,7 +3725,7 @@ function registerDeployCommands(program) {
 function buildProgram() {
   const program = new Command();
   program.name("apm").description(
-    `\u6BD4\u90BB\u661F\u56FE\u547D\u4EE4\u884C\uFF08\u4F1A\u8BDD\u5DE5\u4F5C\u533A\u4E0E\u7814\u53D1\u81EA\u52A8\u5316\uFF09\u3002
+    `\u6BD4\u90BB\u661F\u56FE\u547D\u4EE4\u884C\uFF08\u5DE5\u4F5C\u533A\u4E0E\u7814\u53D1\u81EA\u52A8\u5316\uFF09\u3002
 \u672A\u4F20 --server \u65F6\u4F18\u5148\u4F7F\u7528\u73AF\u5883\u53D8\u91CF AI_PM_SERVER\uFF0C\u5426\u5219\u9ED8\u8BA4 ${DEFAULT_BASE_URL}\u3002`
   ).version(readCliVersion(), "-V, --version", "\u663E\u793A\u7248\u672C\u53F7").helpOption("-h, --help", "\u663E\u793A\u5E2E\u52A9").showHelpAfterError(true);
   program.command("login").description(
@@ -5016,63 +3748,11 @@ function buildProgram() {
   ).action(async () => {
     await runUpdateSkills();
   });
-  program.command("sync-deploy-config").description(
-    "\u4ECE\u5E73\u53F0\u62C9\u53D6\u90E8\u7F72\u914D\u7F6E\uFF0C\u8986\u76D6 .apm/apm.config.json \u4E0E .apm/deploy/README.md\uFF08\u9700\u5DF2 login \u4E14\u5DE5\u4F5C\u7A7A\u95F4\u5DF2\u767B\u8BB0\u5E76\u7ED1\u5B9A\u4ED3\u5E93\uFF09"
-  ).action(async () => {
-    await runSyncDeployConfig();
-  });
-  program.command("sync-project-documents").description(
-    "\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863\uFF1A\u9ED8\u8BA4 pull \u5230 .apm/project/\uFF1B\u52A0 --push \u5C06\u672C\u5730\u53D8\u66F4\u63A8\u9001\u5230\u5E73\u53F0"
-  ).option("--push", "\u63A8\u9001\u672C\u5730 .apm/project/ \u5230\u5E73\u53F0").option("--pull", "\u4ECE\u5E73\u53F0\u62C9\u53D6\u5230 .apm/project/").action(async (opts) => {
-    await runSyncProjectDocuments(opts);
-  });
-  program.command("pull").description(
-    "\u62C9\u53D6\u6C9F\u901A\u7FA4\u6570\u636E\u5230 .apm/sessions/<sessionId>/\uFF0C\u5E76\u540C\u6B65\u90E8\u7F72\u914D\u7F6E\u4E0E\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u5230 .apm/project/"
-  ).argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").action(async (sessionId) => {
-    await runPull(sessionId);
-  });
-  program.command("sync-document").description("\u5C06\u672C\u5730 Markdown \u8986\u76D6\u5F0F upsert \u5230\u5E73\u53F0\u4EFB\u52A1\u6587\u6863").argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").requiredOption(
-    "--file <name>",
-    "\u6587\u6863\u540D\u79F0\uFF08\u5982 PRD \u6216 PRD.md\uFF09\uFF0C\u8BFB\u53D6 .apm/sessions/<sessionId>/docs/ \u4E0B\u5BF9\u5E94\u6587\u4EF6"
-  ).action(async (sessionId, opts) => {
-    await runSyncDocument(sessionId, { file: opts.file });
-  });
-  program.command("append-message").description("\u5411\u5E73\u53F0\u4F1A\u8BDD\u6D88\u606F\u8FFD\u52A0\u5185\u5BB9\uFF08PUT /api/v1/cli/messages/content\uFF09").requiredOption("--id <messageId>", "\u6D88\u606F ID").requiredOption("--content <content>", "\u8981\u8FFD\u52A0\u7684\u6D88\u606F\u5185\u5BB9").action(async (opts) => {
-    await runAppendMessage(opts);
-  });
-  program.command("update-message-status").description("\u66F4\u65B0\u5E73\u53F0\u4F1A\u8BDD\u6D88\u606F\u72B6\u6001").requiredOption("--id <messageId>", "\u6D88\u606F ID").requiredOption(
-    "--status <status>",
-    "CREATED | QUEUED | TYPING | SUCCESS | FAILED | CANCELLED"
-  ).action(async (opts) => {
-    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\u90E8\u7F72\u4E0B\u884C\u901A\u77E5\uFF1B\u542F\u52A8\u524D\u81EA\u52A8 apm update \u5230\u6700\u65B0\u7248"
   ).option("--server <url>", "API \u6839\u5730\u5740\uFF0C\u8986\u76D6 config \u4E2D\u7684 baseUrl").action(async (opts) => {
     await runConnect(opts);
   });
-  program.command("branch").description("\u5207\u6362\u6216\u521B\u5EFA\u4F1A\u8BDD\u5206\u652F feat/session-<sessionId>").argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").option(
-    "-m, --message <text>",
-    "\u5DF2\u5728\u76EE\u6807\u5206\u652F\u4E14\u9700\u63D0\u4EA4\u672C\u5730\u6539\u52A8\u65F6\u4F7F\u7528\u7684\u63D0\u4EA4\u8BF4\u660E"
-  ).action(async (sessionId, opts) => {
-    await runBranch(sessionId, { message: opts.message });
-  });
-  program.command("clean-branches").description(
-    "\u6E05\u7406\u672C\u5730\u4E0E\u8FDC\u7A0B feat/session-* \u5206\u652F\uFF1A\u6C9F\u901A\u7FA4\u4E0D\u5728\u4EFB\u52A1\u5217\u8868\u4E2D\uFF0C\u6216\u5173\u8054\u4EFB\u52A1\u5DF2\u5B8C\u6210\u65F6\u5220\u9664"
-  ).option("--dry-run", "\u4EC5\u5217\u51FA\u5C06\u88AB\u5220\u9664\u7684\u5206\u652F\uFF0C\u4E0D\u5B9E\u9645\u6267\u884C").action(async (opts) => {
-    await runCleanBranches({ dryRun: opts.dryRun });
-  });
-  program.command("create-pr").description(
-    "\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u7684\u4F1A\u8BDD\u7279\u6027\u5206\u652F\u521B\u5EFA PR\uFF08\u6807\u9898\u81EA\u52A8\u52A0 [AI] \u6807\u8BC6\uFF1B\u8FDC\u7A0B\u521B\u5EFA\u5931\u8D25\u65F6\u5E73\u53F0\u6570\u636E\u56DE\u6EDA\uFF09"
-  ).requiredOption("--session <sessionId>", "\u6C9F\u901A\u7FA4 ID").requiredOption("--title <title>", "PR \u6807\u9898").option("--content <content>", "PR \u6B63\u6587\uFF08Markdown\uFF09", "").action(
-    async (opts) => {
-      await runCreatePr({
-        sessionId: opts.session,
-        title: opts.title,
-        content: opts.content ?? ""
-      });
-    }
-  );
   registerDeployCommands(program);
   return program;
 }