ai-project-manage-cli 7.1.36 → 7.1.38

package/dist/index.js

@@ -1000,20 +1000,12 @@ import { Command } from "commander";
 init_config();
 
 // src/commands/init.ts
-import { join as join6 } from "path";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join3 } from "path";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 
 // src/command-utils.ts
 init_config();
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync2,
-  readdirSync,
-  statSync,
-  writeFileSync as writeFileSync2
-} from "fs";
+import { copyFileSync, existsSync, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
 import { basename, dirname, extname, join as join2, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 
@@ -1084,63 +1076,6 @@ function isWorkspaceApmInitialized(workdir) {
   }
   return readdirSync(fsApmDir).length > 0;
 }
-var APM_GITIGNORE_PATTERNS = [
-  /^\.apm\/?$/,
-  /^\.apm\/\*\*$/,
-  /^\*\*\/\.apm\/?$/,
-  /^\*\*\/\.apm\/\*\*$/,
-  /^\/\.apm\/?$/,
-  /^\/\.apm\/\*\*$/
-];
-function normalizeGitignorePattern(line) {
-  const trimmed = line.trim();
-  if (!trimmed || trimmed.startsWith("#")) return "";
-  if (trimmed.startsWith("!")) return "";
-  const hashIndex = trimmed.indexOf("#");
-  return (hashIndex >= 0 ? trimmed.slice(0, hashIndex) : trimmed).trim();
-}
-function gitignoreIgnoresApm(line) {
-  const pattern = normalizeGitignorePattern(line);
-  if (!pattern) return false;
-  return APM_GITIGNORE_PATTERNS.some((re) => re.test(pattern));
-}
-var APM_GITIGNORE_LINE = "**/.apm/**";
-function ensureApmGitignoredInRepo(workdir) {
-  const gitignorePath = join2(workdir, ".gitignore");
-  const fsGitignorePath = toFsPath(gitignorePath);
-  if (!existsSync(fsGitignorePath)) {
-    writeFileSync2(fsGitignorePath, `${APM_GITIGNORE_LINE}
-`, "utf8");
-    return true;
-  }
-  const content = readFileSync2(fsGitignorePath, "utf8");
-  if (content.split(/\r?\n/).some(gitignoreIgnoresApm)) {
-    return false;
-  }
-  const suffix = content.endsWith("\n") || content.length === 0 ? "" : "\n";
-  writeFileSync2(
-    fsGitignorePath,
-    `${content}${suffix}${APM_GITIGNORE_LINE}
-`,
-    "utf8"
-  );
-  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";
@@ -1199,19 +1134,10 @@ async function ensureDirExists(dir) {
 async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
   const dir = workspaceApmDir(cwd);
   const fsDir = toFsPath(dir);
-  if (!existsSync(fsDir)) {
-    mkdirSync2(fsDir, { recursive: true });
-    return;
-  }
-  const st = statSync(fsDir);
-  if (!st.isDirectory()) {
+  if (existsSync(fsDir) && !statSync(fsDir).isDirectory()) {
     throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${dir}`);
   }
-  if (readdirSync(fsDir).length > 0) {
-    throw new Error(
-      "[apm] .apm \u76EE\u5F55\u5DF2\u5B58\u5728\u4E14\u975E\u7A7A\uFF0C\u8BF7\u5148\u5907\u4EFD\u3001\u6E05\u7A7A\u6216\u5220\u9664\u540E\u518D\u6267\u884C init"
-    );
-  }
+  mkdirSync2(fsDir, { recursive: true });
 }
 var WORKSPACE_TEMPLATE_SUBDIRS = [
   "sessions",
@@ -1287,9 +1213,51 @@ async function copyTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
   assertTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
 }
 
+// src/commands/init.ts
+async function initializeWorkspace(workdir, options) {
+  await ensureWorkspaceApmDirForInit(workdir);
+  const apmDir = workspaceApmDir(workdir);
+  await copyTemplateFiles(apmDir, workdir);
+  const trimmedName = options?.name?.trim();
+  if (trimmedName) {
+    const apmConfigPath = toFsPath(join3(apmDir, "apm.config.json"));
+    const config = readFileSync2(apmConfigPath, "utf8");
+    const configJson = JSON.parse(config);
+    configJson.name = trimmedName;
+    writeFileSync2(
+      apmConfigPath,
+      `${JSON.stringify(configJson, null, 2)}
+`,
+      "utf8"
+    );
+  }
+  console.log(`[apm] \u5DF2\u521D\u59CB\u5316\u5DE5\u4F5C\u533A\uFF1A${apmDir}`);
+  return { didInit: true };
+}
+async function ensureWorkspaceInitialized(workdir, options) {
+  if (isWorkspaceApmInitialized(workdir)) {
+    return { didInit: false };
+  }
+  console.log(
+    `[apm] \u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u672A\u68C0\u6D4B\u5230\u5DF2\u521D\u59CB\u5316\u7684 .apm\uFF0C\u6B63\u5728\u81EA\u52A8\u521D\u59CB\u5316\u2026`
+  );
+  return initializeWorkspace(workdir, options);
+}
+async function runInit(name) {
+  const workdir = resolveWorkdirPath();
+  await initializeWorkspace(workdir, { name });
+  console.log(`[apm] \u5DE5\u4F5C\u76EE\u5F55\u8DEF\u5F84\uFF1A${workdir}`);
+}
+
+// src/commands/login.ts
+init_config();
+init_client();
+import { existsSync as existsSync3 } from "fs";
+import { ApiError } from "listpage-http";
+
 // src/deployment-config-sync.ts
 init_client();
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { writeFileSync as writeFileSync4 } from "fs";
 
 // src/git-remote.ts
@@ -1438,46 +1406,6 @@ async function resolveDefaultRemoteBranch(cwd) {
     "[apm] \u65E0\u6CD5\u786E\u5B9A\u8FDC\u7A0B\u9ED8\u8BA4\u5206\u652F\uFF08origin/HEAD\u3001main\u3001master \u5747\u4E0D\u53EF\u7528\uFF09"
   );
 }
-async function hasUpstream(cwd) {
-  try {
-    await execGit(cwd, ["rev-parse", "--abbrev-ref", "@{upstream}"], true);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function pushCurrentBranch(cwd) {
-  if (!await isGitRepo(cwd)) {
-    return false;
-  }
-  const originUrl = await tryReadGitOriginUrl(cwd);
-  if (!originUrl) {
-    console.log("[apm] \u672A\u914D\u7F6E remote.origin\uFF0C\u8DF3\u8FC7 push");
-    return false;
-  }
-  if (await hasUpstream(cwd)) {
-    await execGit(cwd, ["push"]);
-  } else {
-    await execGit(cwd, ["push", "-u", "origin", "HEAD"]);
-  }
-  return true;
-}
-var GITIGNORE_COMMIT_MESSAGE = "chore(apm): ignore .apm directory";
-async function commitAndPushGitignore(workdir) {
-  if (!await isGitRepo(workdir)) {
-    console.log("[apm] \u5F53\u524D\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93\uFF0C\u8BF7\u624B\u52A8\u63D0\u4EA4 .gitignore");
-    return;
-  }
-  await execGit(workdir, ["add", "--", ".gitignore"]);
-  await execGit(workdir, ["commit", "-m", GITIGNORE_COMMIT_MESSAGE]);
-  console.log(`[apm] \u5DF2\u63D0\u4EA4 .gitignore: ${GITIGNORE_COMMIT_MESSAGE}`);
-  const pushed = await pushCurrentBranch(workdir);
-  if (pushed) {
-    console.log("[apm] \u5DF2\u63A8\u9001 .gitignore");
-  } else {
-    console.log("[apm] \u672A\u914D\u7F6E remote.origin\uFF0C\u8BF7\u7A0D\u540E\u624B\u52A8 push .gitignore");
-  }
-}
 
 // src/baseline-resolve.ts
 function formatBaselineDiagnostic(workdirPath, baselineWorkdirPath, diagnostic) {
@@ -1574,11 +1502,11 @@ import {
   statSync as statSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename as basename2, dirname as dirname2, join as join3, relative, resolve as resolve3 } from "path";
+import { basename as basename2, dirname as dirname2, join as join4, relative, resolve as resolve3 } from "path";
 var WORKSPACE_REPOS_MANIFEST = "workspace-repos.json";
 var WORKSPACE_REPOS_VERSION = 1;
 function manifestPath(workdir) {
-  return join3(workspaceApmDir(workdir), WORKSPACE_REPOS_MANIFEST);
+  return join4(workspaceApmDir(workdir), WORKSPACE_REPOS_MANIFEST);
 }
 function absoluteRepoPath(workdir, entry) {
   if (entry.path === "." || entry.path === "") {
@@ -1793,7 +1721,7 @@ async function writeDeploymentConfigContent(apmDir, content, configName) {
     );
     return false;
   }
-  const apmConfigPath = toFsPath(join4(apmDir, "apm.config.json"));
+  const apmConfigPath = toFsPath(join5(apmDir, "apm.config.json"));
   writeFileSync4(apmConfigPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf8");
   console.log(`[apm] \u5DF2\u540C\u6B65\u5E73\u53F0\u90E8\u7F72\u914D\u7F6E: ${configName}`);
@@ -1846,456 +1774,130 @@ ${diagnostic ?? ""}
   return { synced: true, repositoryId, configName: config.name };
 }
 
-// src/project-documents-sync.ts
-init_client();
-init_config();
-import {
-  existsSync as existsSync3,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync4,
-  rmSync,
-  writeFileSync as writeFileSync5
-} from "fs";
-import { createHash } from "crypto";
-import { dirname as dirname3, join as join5, relative as relative2, sep } from "path";
-var MANIFEST_FILE = "manifest.json";
-function normalizeProjectIdForPath(projectId) {
-  const id = projectId.trim();
-  if (!id) {
-    throw new Error("projectId \u4E0D\u80FD\u4E3A\u7A7A");
+// src/commands/login.ts
+async function runLogin(opts) {
+  const baseUrl = (opts.server?.trim() || process.env.AI_PM_SERVER?.trim() || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const apiKey = (opts.apiKey?.trim() || process.env.APM_API_KEY?.trim() || "").replace(/^Bearer\s+/i, "");
+  if (!apiKey.startsWith("cm_")) {
+    console.error("[apm] \u8BF7\u63D0\u4F9B\u6709\u6548\u7684 API Key\uFF08cm_ \u5F00\u5934\uFF09");
+    console.error("[apm] \u7528\u6CD5: apm login --api-key cm_xxx [--server URL]");
+    process.exit(1);
   }
-  if (id.includes("..") || id.includes("/") || id.includes("\\") || id.includes("\0")) {
-    throw new Error(`\u975E\u6CD5 projectId: ${projectId}`);
+  const api = createApmApiClient({
+    baseUrl,
+    clientMachineId: "",
+    apiKey
+  });
+  let data;
+  try {
+    data = await api.cli.me({});
+  } catch (raw) {
+    if (raw instanceof ApiError) {
+      const err = raw;
+      console.error(
+        `[apm] API Key \u9A8C\u8BC1\u5931\u8D25 (${err.httpStatus ?? err.code}):`,
+        err.message
+      );
+      process.exit(1);
+    }
+    console.error("[apm] \u8BF7\u6C42\u5931\u8D25:", raw instanceof Error ? raw.message : raw);
+    process.exit(1);
   }
-  return id;
-}
-function projectDocumentsDir(apmRoot, projectId) {
-  const id = normalizeProjectIdForPath(projectId);
-  return join5(apmRoot ?? workspaceApmDir(), "project", id);
-}
-function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
-  const normalized = normalizeLocalDocumentPath(documentPath);
-  return join5(
-    projectDocumentsDir(apmRoot, projectId),
-    ...normalized.split("/")
+  const clientMachineId = data?.clientMachineId;
+  if (!clientMachineId) {
+    console.error("[apm] \u54CD\u5E94\u7F3A\u5C11 clientMachineId");
+    process.exit(1);
+  }
+  const cfg = {
+    baseUrl,
+    clientMachineId,
+    apiKey
+  };
+  await writeApmConfig(cfg);
+  console.error(`[apm] \u5DF2\u4FDD\u5B58\u767B\u5F55\u4FE1\u606F: ${APM_CONFIG_PATH}`);
+  console.log(
+    JSON.stringify(
+      {
+        clientMachineId: cfg.clientMachineId,
+        clientName: data.clientName,
+        baseUrl: cfg.baseUrl
+      },
+      null,
+      2
+    )
   );
+  const workdir = resolveWorkdirPath();
+  const apmDir = workspaceApmDir(workdir);
+  if (existsSync3(apmDir)) {
+    await syncRemoteDeploymentConfig(workdir, apmDir);
+  }
 }
-function normalizeLocalDocumentPath(path19) {
-  const trimmed = path19.trim().replace(/\\/g, "/");
-  if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path19}`);
+
+// src/commands/branch.ts
+init_client();
+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");
   }
-  const segments = trimmed.split("/").filter(Boolean);
-  if (segments.some((segment) => segment === ".." || segment === ".")) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path19}`);
+  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 segments.join("/");
-}
-function hashLocalFileContent(content) {
-  return createHash("sha256").update(content, "utf8").digest("hex");
+  return `${SESSION_BRANCH_PREFIX}${id}`;
 }
-function readLocalManifest(apmRoot, projectId) {
-  const manifestPath3 = join5(
-    projectDocumentsDir(apmRoot, projectId),
-    MANIFEST_FILE
-  );
-  if (!existsSync3(manifestPath3)) {
+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 localBranchExists(cwd, branch) {
   try {
-    return JSON.parse(
-      readFileSync4(manifestPath3, "utf8")
+    await execGit(
+      cwd,
+      ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
+      true
     );
+    return true;
   } catch {
-    return null;
+    return false;
   }
 }
-function listLocalDocumentPaths(apmRoot, projectId) {
-  const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync3(root)) {
-    return [];
+async function commitWorkingTreeIfDirty(cwd, message) {
+  await ensureGitRepo(cwd);
+  if (!await isWorkingTreeDirty(cwd)) {
+    return false;
   }
-  const paths = [];
-  const walk = (dir) => {
-    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const abs = join5(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(abs);
-        continue;
-      }
-      if (entry.isFile() && entry.name === MANIFEST_FILE) {
-        continue;
-      }
-      const rel = relative2(root, abs).split(sep).join("/");
-      paths.push(rel);
-    }
-  };
-  walk(root);
-  return paths.sort();
+  const commitMessage = message?.trim() || `chore(apm): \u540C\u6B65\u5DE5\u4F5C\u533A (${await getCurrentBranch(cwd)})`;
+  await execGit(cwd, ["add", "-A"]);
+  await execGit(cwd, ["commit", "-m", commitMessage]);
+  console.log(`[apm] \u5DF2\u63D0\u4EA4\u5DE5\u4F5C\u533A\u53D8\u66F4: ${commitMessage}`);
+  return true;
 }
-function diffManifestPaths(remote, local) {
-  const remoteMap = new Map(
-    (remote?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
-  );
-  const localMap = new Map(
-    (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
-  );
-  const download = [];
-  for (const [path19, hash] of remoteMap) {
-    if (localMap.get(path19) !== hash) {
-      download.push(path19);
-    }
-  }
-  const deleteLocal = [];
-  for (const path19 of localMap.keys()) {
-    if (!remoteMap.has(path19)) {
-      deleteLocal.push(path19);
-    }
-  }
-  return { download, deleteLocal };
-}
-async function resolveProjectIdForSync(api, workdirPath, options) {
-  const explicit = options?.projectId?.trim();
-  if (explicit) {
-    return { projectId: explicit, diagnostic: null };
-  }
-  try {
-    const baseline = await api.cli.workspaceBaseline({ workdirPath });
-    const projectId = baseline.projectId?.trim() || null;
-    if (projectId) {
-      return { projectId, diagnostic: null };
-    }
-    const projectIds = baseline.projectIds ?? [];
-    if (projectIds.length === 0) {
-      return {
-        projectId: null,
-        diagnostic: baseline.diagnostic?.message ?? `\u5DE5\u4F5C\u7A7A\u95F4\u672A\u5173\u8054\u9879\u76EE\uFF0C\u65E0\u6CD5\u540C\u6B65\u9879\u76EE\u6587\u6863\uFF08\u76EE\u5F55\uFF1A${workdirPath}\uFF09\u3002
-\u8BF7\u5728\u5E73\u53F0\u5C06\u5DE5\u4F5C\u7A7A\u95F4\u5173\u8054\u5230\u552F\u4E00\u9879\u76EE\u3002`
-      };
-    }
-    return {
-      projectId: null,
-      diagnostic: `\u5DE5\u4F5C\u7A7A\u95F4\u5173\u8054\u4E86 ${projectIds.length} \u4E2A\u9879\u76EE\uFF0C\u65E0\u6CD5\u786E\u5B9A\u540C\u6B65\u76EE\u6807\u3002
-\u8BF7\u786E\u4FDD\u8BE5\u5DE5\u4F5C\u7A7A\u95F4\u53EA\u5173\u8054\u4E00\u4E2A\u9879\u76EE\u540E\u518D\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002`
-    };
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    return {
-      projectId: null,
-      diagnostic: detail.replace(/^\[apm\]\s*/, "")
-    };
-  }
-}
-async function syncProjectDocumentsPull(workdirPath, apmDir, options) {
-  const empty = {
-    synced: false,
-    projectId: null,
-    downloaded: 0,
-    deleted: 0
-  };
-  const cfg = await tryReadApmConfig();
-  if (!cfg || !resolveApiKey(cfg)) {
-    console.log(
-      "[apm] \u672A\u68C0\u6D4B\u5230\u767B\u5F55\u4FE1\u606F\uFF0C\u8DF3\u8FC7\u9879\u76EE\u6587\u6863\u540C\u6B65\u3002\n[apm] \u8BF7\u5148\u6267\u884C apm login\u3002"
-    );
-    return empty;
-  }
-  const api = createApmApiClient(cfg);
-  const { projectId, diagnostic } = await resolveProjectIdForSync(
-    api,
-    workdirPath,
-    options
-  );
-  if (!projectId) {
-    console.log(`[apm] \u672A\u80FD\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002
-${diagnostic ?? ""}`);
-    return empty;
-  }
-  const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
-  const docsDir = projectDocumentsDir(targetApmDir, projectId);
-  await ensureDirExists(docsDir);
-  const { manifest: remoteManifest } = await api.cli.getProjectDocumentManifest(
-    { projectId }
-  );
-  if (!remoteManifest) {
-    console.log(`[apm] \u9879\u76EE ${projectId} \u65E0\u9879\u76EE\u6587\u6863 manifest\uFF0C\u8DF3\u8FC7\u540C\u6B65\u3002`);
-    return { ...empty, projectId };
-  }
-  const localManifest = readLocalManifest(targetApmDir, projectId);
-  const { download, deleteLocal } = diffManifestPaths(
-    remoteManifest,
-    localManifest
-  );
-  let downloaded = 0;
-  if (download.length > 0) {
-    const { list } = await api.cli.listProjectDocuments({
-      projectId,
-      paths: download.join(",")
-    });
-    for (const doc of list) {
-      const absPath = toFsPath(
-        projectDocumentLocalPath(targetApmDir, projectId, doc.path)
-      );
-      await ensureDirExists(dirname3(absPath));
-      writeFileSync5(absPath, doc.content, "utf8");
-      downloaded += 1;
-    }
-  }
-  let deleted = 0;
-  for (const path19 of deleteLocal) {
-    const absPath = toFsPath(
-      projectDocumentLocalPath(targetApmDir, projectId, path19)
-    );
-    if (existsSync3(absPath)) {
-      rmSync(absPath, { force: true });
-      deleted += 1;
-    }
-  }
-  writeFileSync5(
-    toFsPath(join5(docsDir, MANIFEST_FILE)),
-    `${JSON.stringify(remoteManifest, null, 2)}
-`,
-    "utf8"
-  );
-  console.log(
-    `[apm] \u5DF2\u540C\u6B65\u9879\u76EE\u6587\u6863: projectId=${projectId} \u4E0B\u8F7D ${downloaded}\uFF0C\u5220\u9664\u672C\u5730 ${deleted} \u2192 .apm/project/${projectId}/`
-  );
-  return {
-    synced: true,
-    projectId,
-    downloaded,
-    deleted
-  };
-}
-async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot, options) {
-  const api = createApmApiClient(cfg);
-  const { projectId } = await resolveProjectIdForSync(
-    api,
-    workdirPath,
-    options
-  );
-  if (!projectId) {
-    return 0;
-  }
-  const targetApmDir = apmRoot ?? workspaceApmDir(workdirPath);
-  const localPaths = listLocalDocumentPaths(targetApmDir, projectId);
-  if (localPaths.length === 0) {
-    console.log("[apm] \u9879\u76EE\u6587\u6863\u65E0\u672C\u5730\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u63A8\u9001");
-    return 0;
-  }
-  const remoteManifest = (await api.cli.getProjectDocumentManifest({ projectId })).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 path19 of localPaths) {
-    const absPath = toFsPath(
-      projectDocumentLocalPath(targetApmDir, projectId, path19)
-    );
-    const content = readFileSync4(absPath, "utf8");
-    const contentHash = hashLocalFileContent(content);
-    if (remoteHashByPath.get(path19) === contentHash) {
-      continue;
-    }
-    await api.cli.upsertProjectDocument({
-      projectId,
-      path: path19,
-      content,
-      description: remoteDescriptionByPath.get(path19) ?? void 0
-    });
-    synced += 1;
-    console.log(`[apm] \u5DF2\u540C\u6B65\u9879\u76EE\u6587\u6863: ${path19}`);
-  }
-  if (synced === 0) {
-    console.log("[apm] \u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
-  }
-  return synced;
-}
-
-// src/commands/init.ts
-async function ensureWorkspaceInitialized(workdir, options) {
-  if (isWorkspaceApmInitialized(workdir)) {
-    return { didInit: false };
-  }
-  console.log(
-    `[apm] \u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u672A\u68C0\u6D4B\u5230\u5DF2\u521D\u59CB\u5316\u7684 .apm\uFF0C\u6B63\u5728\u81EA\u52A8\u521D\u59CB\u5316\u2026`
-  );
-  await ensureWorkspaceApmDirForInit(workdir);
-  if (ensureApmGitignoredInRepo(workdir)) {
-    console.log("[apm] \u5DF2\u5728 .gitignore \u4E2D\u6DFB\u52A0 **/.apm/**");
-    await commitAndPushGitignore(workdir);
-  }
-  const apmDir = workspaceApmDir(workdir);
-  await copyTemplateFiles(apmDir, workdir);
-  const syncResult = await syncRemoteDeploymentConfig(workdir, apmDir);
-  await syncProjectDocumentsPull(workdir, apmDir);
-  const trimmedName = options?.name?.trim();
-  if (trimmedName) {
-    const apmConfigPath = toFsPath(join6(apmDir, "apm.config.json"));
-    const config = readFileSync5(apmConfigPath, "utf8");
-    const configJson = JSON.parse(config);
-    configJson.name = trimmedName;
-    writeFileSync6(
-      apmConfigPath,
-      `${JSON.stringify(configJson, null, 2)}
-`,
-      "utf8"
-    );
-  }
-  console.log(`[apm] \u5DF2\u521D\u59CB\u5316\u5DE5\u4F5C\u533A\uFF1A${apmDir}`);
-  return { didInit: true, syncResult };
-}
-async function runInit(name) {
-  const workdir = resolveWorkdirPath();
-  await ensureWorkspaceApmDirForInit(workdir);
-  const { didInit, syncResult } = await ensureWorkspaceInitialized(workdir, {
-    name
-  });
-  if (!didInit) {
-    throw new Error(
-      "[apm] .apm \u76EE\u5F55\u5DF2\u5B58\u5728\u4E14\u975E\u7A7A\uFF0C\u8BF7\u5148\u5907\u4EFD\u3001\u6E05\u7A7A\u6216\u5220\u9664\u540E\u518D\u6267\u884C init"
-    );
-  }
-  console.log(`[apm] \u5DE5\u4F5C\u76EE\u5F55\u8DEF\u5F84\uFF1A${workdir}`);
-  if (syncResult && !syncResult.synced) {
-    console.log(
-      "[apm] \u5F53\u524D .apm/apm.config.json \u4E3A\u6A21\u677F\u9ED8\u8BA4\u503C\uFF1B\u5B8C\u6210\u5E73\u53F0\u767B\u8BB0\u540E\u6267\u884C apm sync-deploy-config"
-    );
-  }
-  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
-init_config();
-init_client();
-import { existsSync as existsSync4 } 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(/\/+$/, "");
-  const apiKey = (opts.apiKey?.trim() || process.env.APM_API_KEY?.trim() || "").replace(/^Bearer\s+/i, "");
-  if (!apiKey.startsWith("cm_")) {
-    console.error("[apm] \u8BF7\u63D0\u4F9B\u6709\u6548\u7684 API Key\uFF08cm_ \u5F00\u5934\uFF09");
-    console.error("[apm] \u7528\u6CD5: apm login --api-key cm_xxx [--server URL]");
-    process.exit(1);
-  }
-  const api = createApmApiClient({
-    baseUrl,
-    clientMachineId: "",
-    apiKey
-  });
-  let data;
-  try {
-    data = await api.cli.me({});
-  } catch (raw) {
-    if (raw instanceof ApiError) {
-      const err = raw;
-      console.error(
-        `[apm] API Key \u9A8C\u8BC1\u5931\u8D25 (${err.httpStatus ?? err.code}):`,
-        err.message
-      );
-      process.exit(1);
-    }
-    console.error("[apm] \u8BF7\u6C42\u5931\u8D25:", raw instanceof Error ? raw.message : raw);
-    process.exit(1);
-  }
-  const clientMachineId = data?.clientMachineId;
-  if (!clientMachineId) {
-    console.error("[apm] \u54CD\u5E94\u7F3A\u5C11 clientMachineId");
-    process.exit(1);
-  }
-  const cfg = {
-    baseUrl,
-    clientMachineId,
-    apiKey
-  };
-  await writeApmConfig(cfg);
-  console.error(`[apm] \u5DF2\u4FDD\u5B58\u767B\u5F55\u4FE1\u606F: ${APM_CONFIG_PATH}`);
-  console.log(
-    JSON.stringify(
-      {
-        clientMachineId: cfg.clientMachineId,
-        clientName: data.clientName,
-        baseUrl: cfg.baseUrl
-      },
-      null,
-      2
-    )
-  );
-  const workdir = resolveWorkdirPath();
-  const apmDir = workspaceApmDir(workdir);
-  if (existsSync4(apmDir)) {
-    await syncRemoteDeploymentConfig(workdir, apmDir);
-  }
-}
-
-// src/commands/branch.ts
-init_client();
-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 localBranchExists(cwd, branch) {
-  try {
-    await execGit(
-      cwd,
-      ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
-      true
-    );
-    return true;
-  } catch {
-    return false;
-  }
-}
-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 execGit(cwd, ["add", "-A"]);
-  await execGit(cwd, ["commit", "-m", commitMessage]);
-  console.log(`[apm] \u5DF2\u63D0\u4EA4\u5DE5\u4F5C\u533A\u53D8\u66F4: ${commitMessage}`);
-  return true;
-}
-async function ensureFeatureBranch(branch, baselineBranch, options) {
-  const cwd = options.cwd ?? process.cwd();
-  const gitRoot = await resolveGitRepoRoot(cwd);
-  const commitMessage = options.message?.trim() || `chore(apm): \u540C\u6B65\u5DE5\u4F5C\u533A (${branch})`;
-  await ensureGitRepo(gitRoot);
-  await ensureRemoteBaselineBranch(gitRoot, baselineBranch);
-  const current = await getCurrentBranch(gitRoot);
-  const dirty = await isWorkingTreeDirty(gitRoot);
-  if (dirty) {
-    if (current === branch) {
-      await commitWorkingTreeIfDirty(gitRoot, commitMessage);
-    } else {
-      await execGit(gitRoot, [
-        "stash",
-        "push",
-        "-u",
-        "-m",
-        `apm: switch to ${branch}`
-      ]);
+async function ensureFeatureBranch(branch, baselineBranch, options) {
+  const cwd = options.cwd ?? process.cwd();
+  const gitRoot = await resolveGitRepoRoot(cwd);
+  const commitMessage = options.message?.trim() || `chore(apm): \u540C\u6B65\u5DE5\u4F5C\u533A (${branch})`;
+  await ensureGitRepo(gitRoot);
+  await ensureRemoteBaselineBranch(gitRoot, baselineBranch);
+  const current = await getCurrentBranch(gitRoot);
+  const dirty = await isWorkingTreeDirty(gitRoot);
+  if (dirty) {
+    if (current === branch) {
+      await commitWorkingTreeIfDirty(gitRoot, commitMessage);
+    } else {
+      await execGit(gitRoot, [
+        "stash",
+        "push",
+        "-u",
+        "-m",
+        `apm: switch to ${branch}`
+      ]);
     }
   }
   const onTargetBranch = await getCurrentBranch(gitRoot) === branch;
@@ -2682,7 +2284,7 @@ async function runCleanBranches(options = {}) {
 
 // src/commands/pull.ts
 init_client();
-import { writeFileSync as writeFileSync10 } from "fs";
+import { writeFileSync as writeFileSync9 } from "fs";
 import { join as join10 } from "path";
 import { stringify as yamlStringify } from "yaml";
 
@@ -2716,9 +2318,9 @@ function formatSessionMessagesXml(sessionId, messages) {
 }
 
 // src/commands/sync-session-attachments.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
-import { join as join7 } from "path";
-var MANIFEST_FILE2 = ".sync-manifest.json";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join6 } from "path";
+var MANIFEST_FILE = ".sync-manifest.json";
 async function downloadAttachment(cfg, attachmentId) {
   const base = cfg.baseUrl.trim().replace(/\/+$/, "");
   const url = `${base}/api/v1/tasks/attachments/file?${new URLSearchParams({
@@ -2733,13 +2335,13 @@ async function downloadAttachment(cfg, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path19 = join7(dir, MANIFEST_FILE2);
-  if (!existsSync5(path19)) {
+  const path19 = join6(dir, MANIFEST_FILE);
+  if (!existsSync4(path19)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync6(path19, "utf8")
+      readFileSync4(path19, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -2749,15 +2351,15 @@ function loadManifest(dir) {
   return { version: 1, attachments: {} };
 }
 function saveManifest(dir, manifest) {
-  writeFileSync7(
-    join7(dir, MANIFEST_FILE2),
+  writeFileSync5(
+    join6(dir, MANIFEST_FILE),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
 function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync5(dest)) return false;
+  if (!entry || !existsSync4(dest)) return false;
   if (entry.name !== item.name) return false;
   const createdAt = item.createdAt ?? "";
   return entry.createdAt === createdAt;
@@ -2772,7 +2374,7 @@ async function syncAttachmentsToDirectory(cfg, attachments, dir, logLabel) {
   const nextManifest = { version: 1, attachments: {} };
   const names = [];
   for (const item of attachments) {
-    const dest = join7(dir, item.name);
+    const dest = join6(dir, item.name);
     const entry = manifest.attachments[item.id];
     const createdAt = item.createdAt ?? "";
     names.push(item.name);
@@ -2782,7 +2384,7 @@ async function syncAttachmentsToDirectory(cfg, attachments, dir, logLabel) {
       continue;
     }
     const buffer = await downloadAttachment(cfg, item.id);
-    writeFileSync7(dest, buffer);
+    writeFileSync5(dest, buffer);
     nextManifest.attachments[item.id] = {
       name: item.name,
       createdAt
@@ -2793,7 +2395,7 @@ async function syncAttachmentsToDirectory(cfg, attachments, dir, logLabel) {
   return names;
 }
 async function syncSessionAttachments(cfg, sessionId, attachments, apmRoot) {
-  const dir = join7(sessionDir(sessionId, apmRoot), SESSION_ATTACHMENTS_SUBDIR);
+  const dir = join6(sessionDir(sessionId, apmRoot), SESSION_ATTACHMENTS_SUBDIR);
   return syncAttachmentsToDirectory(
     cfg,
     attachments,
@@ -2804,46 +2406,46 @@ async function syncSessionAttachments(cfg, sessionId, attachments, apmRoot) {
 
 // src/rules-sync.ts
 init_client();
-import { basename as basename3, extname as extname2, join as join9 } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync9 } from "fs";
+import { basename as basename3, extname as extname2, join as join8 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
 
 // src/skills-sync.ts
 import {
   copyFileSync as copyFileSync2,
   cpSync,
-  existsSync as existsSync6,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync4,
-  rmSync as rmSync2,
+  readdirSync as readdirSync3,
+  rmSync,
   statSync as statSync3,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync6
 } from "fs";
-import { join as join8 } from "path";
-var AGENTS_TEMPLATE_PATH = join8(CLI_TEMPLATE_DIR, "AGENTS.md");
-var BASE_SKILLS_TEMPLATE_DIR = join8(CLI_TEMPLATE_DIR, "skills");
-var BASE_RULES_TEMPLATE_DIR = join8(CLI_TEMPLATE_DIR, "rules");
+import { join as join7 } from "path";
+var AGENTS_TEMPLATE_PATH = join7(CLI_TEMPLATE_DIR, "AGENTS.md");
+var BASE_SKILLS_TEMPLATE_DIR = join7(CLI_TEMPLATE_DIR, "skills");
+var BASE_RULES_TEMPLATE_DIR = join7(CLI_TEMPLATE_DIR, "rules");
 function sanitizeSkillDirName(name) {
   const trimmed = name.trim();
   if (!trimmed) return "skill";
   return trimmed.replace(/[/\\:*?"<>|]/g, "_");
 }
 function listBaseSkillDirNames() {
-  if (!existsSync6(BASE_SKILLS_TEMPLATE_DIR)) return [];
-  return readdirSync4(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
-    const path19 = join8(BASE_SKILLS_TEMPLATE_DIR, name);
+  if (!existsSync5(BASE_SKILLS_TEMPLATE_DIR)) return [];
+  return readdirSync3(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
+    const path19 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
     return statSync3(path19).isDirectory();
   });
 }
 function syncAgentsGuide(apmDir) {
-  if (!existsSync6(AGENTS_TEMPLATE_PATH)) return false;
+  if (!existsSync5(AGENTS_TEMPLATE_PATH)) return false;
   mkdirSync4(apmDir, { recursive: true });
-  copyFileSync2(AGENTS_TEMPLATE_PATH, join8(apmDir, "AGENTS.md"));
+  copyFileSync2(AGENTS_TEMPLATE_PATH, join7(apmDir, "AGENTS.md"));
   return true;
 }
 function listBaseRuleFileNames() {
-  if (!existsSync6(BASE_RULES_TEMPLATE_DIR)) return [];
-  return readdirSync4(BASE_RULES_TEMPLATE_DIR).filter((name) => {
-    const path19 = join8(BASE_RULES_TEMPLATE_DIR, name);
+  if (!existsSync5(BASE_RULES_TEMPLATE_DIR)) return [];
+  return readdirSync3(BASE_RULES_TEMPLATE_DIR).filter((name) => {
+    const path19 = join7(BASE_RULES_TEMPLATE_DIR, name);
     return statSync3(path19).isFile();
   });
 }
@@ -2851,144 +2453,413 @@ function syncBaseRules(rulesDir) {
   mkdirSync4(rulesDir, { recursive: true });
   const names = listBaseRuleFileNames();
   for (const name of names) {
-    const src = join8(BASE_RULES_TEMPLATE_DIR, name);
-    const dest = join8(rulesDir, name);
+    const src = join7(BASE_RULES_TEMPLATE_DIR, name);
+    const dest = join7(rulesDir, name);
     copyFileSync2(src, dest);
   }
-  return names;
+  return names;
+}
+function syncBaseSkills(skillsDir) {
+  mkdirSync4(skillsDir, { recursive: true });
+  const names = listBaseSkillDirNames();
+  for (const name of names) {
+    const src = join7(BASE_SKILLS_TEMPLATE_DIR, name);
+    const dest = join7(skillsDir, name);
+    cpSync(src, dest, { recursive: true, force: true });
+  }
+  return names;
+}
+function syncSupplementarySkills(skillsDir, list) {
+  const baseNames = new Set(listBaseSkillDirNames());
+  const apiDirNames = /* @__PURE__ */ new Set();
+  const written = [];
+  const skipped = [];
+  for (const skill of list) {
+    const dirName = sanitizeSkillDirName(skill.name);
+    apiDirNames.add(dirName);
+    if (baseNames.has(dirName)) {
+      skipped.push(dirName);
+      continue;
+    }
+    const skillDir = join7(skillsDir, dirName);
+    mkdirSync4(skillDir, { recursive: true });
+    writeFileSync6(join7(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
+    written.push(dirName);
+  }
+  const removed = [];
+  if (!existsSync5(skillsDir)) return { written, skipped, removed };
+  for (const entry of readdirSync3(skillsDir)) {
+    const full = join7(skillsDir, entry);
+    if (!statSync3(full).isDirectory()) continue;
+    if (baseNames.has(entry)) continue;
+    if (apiDirNames.has(entry)) continue;
+    rmSync(full, { recursive: true, force: true });
+    removed.push(entry);
+  }
+  return { written, skipped, removed };
+}
+
+// src/rules-sync.ts
+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 (extname2(sanitized).toLowerCase() === ".md") return sanitized;
+  return `${sanitized}.md`;
+}
+function loadManifest2(rulesDir) {
+  const path19 = join8(rulesDir, MANIFEST_FILE2);
+  if (!existsSync6(toFsPath(path19))) {
+    return { version: 1, rules: {} };
+  }
+  try {
+    const parsed = JSON.parse(
+      readFileSync5(toFsPath(path19), "utf8")
+    );
+    if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
+      return parsed;
+    }
+  } catch {
+  }
+  return { version: 1, rules: {} };
+}
+function saveManifest2(rulesDir, manifest) {
+  writeFileSync7(
+    toFsPath(join8(rulesDir, MANIFEST_FILE2)),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+}
+function isBaseRuleFileName(fileName) {
+  return listBaseRuleFileNames().includes(basename3(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 = readFileSync5(toFsPath(dest), "utf8");
+  return localContent === (rule.content ?? "");
+}
+async function syncPlatformRules(cfg, sessionId, workdirPath, apmRoot) {
+  const api = createApmApiClient(cfg);
+  const baseline = await resolveBranchBaseline(api, 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;
+    }
+    writeFileSync7(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))) {
+      rmSync2(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/project-documents-sync.ts
+init_client();
+init_config();
+import {
+  existsSync as existsSync7,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync6,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync8
+} from "fs";
+import { createHash } from "crypto";
+import { dirname as dirname3, join as join9, relative as relative2, sep } from "path";
+var MANIFEST_FILE3 = "manifest.json";
+function normalizeProjectIdForPath(projectId) {
+  const id = projectId.trim();
+  if (!id) {
+    throw new Error("projectId \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (id.includes("..") || id.includes("/") || id.includes("\\") || id.includes("\0")) {
+    throw new Error(`\u975E\u6CD5 projectId: ${projectId}`);
+  }
+  return id;
+}
+function projectDocumentsDir(apmRoot, projectId) {
+  const id = normalizeProjectIdForPath(projectId);
+  return join9(apmRoot ?? workspaceApmDir(), "project", id);
+}
+function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
+  const normalized = normalizeLocalDocumentPath(documentPath);
+  return join9(
+    projectDocumentsDir(apmRoot, projectId),
+    ...normalized.split("/")
+  );
+}
+function normalizeLocalDocumentPath(path19) {
+  const trimmed = path19.trim().replace(/\\/g, "/");
+  if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path19}`);
+  }
+  const segments = trimmed.split("/").filter(Boolean);
+  if (segments.some((segment) => segment === ".." || segment === ".")) {
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path19}`);
+  }
+  return segments.join("/");
+}
+function hashLocalFileContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function readLocalManifest(apmRoot, projectId) {
+  const manifestPath3 = join9(
+    projectDocumentsDir(apmRoot, projectId),
+    MANIFEST_FILE3
+  );
+  if (!existsSync7(manifestPath3)) {
+    return null;
+  }
+  try {
+    return JSON.parse(
+      readFileSync6(manifestPath3, "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+function listLocalDocumentPaths(apmRoot, projectId) {
+  const root = projectDocumentsDir(apmRoot, projectId);
+  if (!existsSync7(root)) {
+    return [];
+  }
+  const paths = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+      const abs = join9(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(abs);
+        continue;
+      }
+      if (entry.isFile() && entry.name === MANIFEST_FILE3) {
+        continue;
+      }
+      const rel = relative2(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])
+  );
+  const localMap = new Map(
+    (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
+  );
+  const download = [];
+  for (const [path19, hash] of remoteMap) {
+    if (localMap.get(path19) !== hash) {
+      download.push(path19);
+    }
+  }
+  const deleteLocal = [];
+  for (const path19 of localMap.keys()) {
+    if (!remoteMap.has(path19)) {
+      deleteLocal.push(path19);
+    }
+  }
+  return { download, deleteLocal };
 }
-function syncBaseSkills(skillsDir) {
-  mkdirSync4(skillsDir, { recursive: true });
-  const names = listBaseSkillDirNames();
-  for (const name of names) {
-    const src = join8(BASE_SKILLS_TEMPLATE_DIR, name);
-    const dest = join8(skillsDir, name);
-    cpSync(src, dest, { recursive: true, force: true });
+async function resolveProjectIdForSync(api, workdirPath, options) {
+  const explicit = options?.projectId?.trim();
+  if (explicit) {
+    return { projectId: explicit, diagnostic: null };
   }
-  return names;
-}
-function syncSupplementarySkills(skillsDir, list) {
-  const baseNames = new Set(listBaseSkillDirNames());
-  const apiDirNames = /* @__PURE__ */ new Set();
-  const written = [];
-  const skipped = [];
-  for (const skill of list) {
-    const dirName = sanitizeSkillDirName(skill.name);
-    apiDirNames.add(dirName);
-    if (baseNames.has(dirName)) {
-      skipped.push(dirName);
-      continue;
+  try {
+    const baseline = await api.cli.workspaceBaseline({ workdirPath });
+    const projectId = baseline.projectId?.trim() || null;
+    if (projectId) {
+      return { projectId, diagnostic: null };
     }
-    const skillDir = join8(skillsDir, dirName);
-    mkdirSync4(skillDir, { recursive: true });
-    writeFileSync8(join8(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
-    written.push(dirName);
-  }
-  const removed = [];
-  if (!existsSync6(skillsDir)) return { written, skipped, removed };
-  for (const entry of readdirSync4(skillsDir)) {
-    const full = join8(skillsDir, entry);
-    if (!statSync3(full).isDirectory()) continue;
-    if (baseNames.has(entry)) continue;
-    if (apiDirNames.has(entry)) continue;
-    rmSync2(full, { recursive: true, force: true });
-    removed.push(entry);
+    const projectIds = baseline.projectIds ?? [];
+    if (projectIds.length === 0) {
+      return {
+        projectId: null,
+        diagnostic: baseline.diagnostic?.message ?? `\u5DE5\u4F5C\u7A7A\u95F4\u672A\u5173\u8054\u9879\u76EE\uFF0C\u65E0\u6CD5\u540C\u6B65\u9879\u76EE\u6587\u6863\uFF08\u76EE\u5F55\uFF1A${workdirPath}\uFF09\u3002
+\u8BF7\u5728\u5E73\u53F0\u5C06\u5DE5\u4F5C\u7A7A\u95F4\u5173\u8054\u5230\u552F\u4E00\u9879\u76EE\u3002`
+      };
+    }
+    return {
+      projectId: null,
+      diagnostic: `\u5DE5\u4F5C\u7A7A\u95F4\u5173\u8054\u4E86 ${projectIds.length} \u4E2A\u9879\u76EE\uFF0C\u65E0\u6CD5\u786E\u5B9A\u540C\u6B65\u76EE\u6807\u3002
+\u8BF7\u786E\u4FDD\u8BE5\u5DE5\u4F5C\u7A7A\u95F4\u53EA\u5173\u8054\u4E00\u4E2A\u9879\u76EE\u540E\u518D\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002`
+    };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      projectId: null,
+      diagnostic: detail.replace(/^\[apm\]\s*/, "")
+    };
   }
-  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 path19 = join9(rulesDir, MANIFEST_FILE3);
-  if (!existsSync7(toFsPath(path19))) {
-    return { version: 1, rules: {} };
+async function syncProjectDocumentsPull(workdirPath, apmDir, options) {
+  const empty = {
+    synced: false,
+    projectId: null,
+    downloaded: 0,
+    deleted: 0
+  };
+  const cfg = await tryReadApmConfig();
+  if (!cfg || !resolveApiKey(cfg)) {
+    console.log(
+      "[apm] \u672A\u68C0\u6D4B\u5230\u767B\u5F55\u4FE1\u606F\uFF0C\u8DF3\u8FC7\u9879\u76EE\u6587\u6863\u540C\u6B65\u3002\n[apm] \u8BF7\u5148\u6267\u884C apm login\u3002"
+    );
+    return empty;
   }
-  try {
-    const parsed = JSON.parse(
-      readFileSync7(toFsPath(path19), "utf8")
+  const api = createApmApiClient(cfg);
+  const { projectId, diagnostic } = await resolveProjectIdForSync(
+    api,
+    workdirPath,
+    options
+  );
+  if (!projectId) {
+    console.log(`[apm] \u672A\u80FD\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002
+${diagnostic ?? ""}`);
+    return empty;
+  }
+  const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
+  const docsDir = projectDocumentsDir(targetApmDir, projectId);
+  await ensureDirExists(docsDir);
+  const { manifest: remoteManifest } = await api.cli.getProjectDocumentManifest(
+    { projectId }
+  );
+  if (!remoteManifest) {
+    console.log(`[apm] \u9879\u76EE ${projectId} \u65E0\u9879\u76EE\u6587\u6863 manifest\uFF0C\u8DF3\u8FC7\u540C\u6B65\u3002`);
+    return { ...empty, projectId };
+  }
+  const localManifest = readLocalManifest(targetApmDir, projectId);
+  const { download, deleteLocal } = diffManifestPaths(
+    remoteManifest,
+    localManifest
+  );
+  let downloaded = 0;
+  if (download.length > 0) {
+    const { list } = await api.cli.listProjectDocuments({
+      projectId,
+      paths: download.join(",")
+    });
+    for (const doc of list) {
+      const absPath = toFsPath(
+        projectDocumentLocalPath(targetApmDir, projectId, doc.path)
+      );
+      await ensureDirExists(dirname3(absPath));
+      writeFileSync8(absPath, doc.content, "utf8");
+      downloaded += 1;
+    }
+  }
+  let deleted = 0;
+  for (const path19 of deleteLocal) {
+    const absPath = toFsPath(
+      projectDocumentLocalPath(targetApmDir, projectId, path19)
     );
-    if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
-      return parsed;
+    if (existsSync7(absPath)) {
+      rmSync3(absPath, { force: true });
+      deleted += 1;
     }
-  } catch {
   }
-  return { version: 1, rules: {} };
-}
-function saveManifest2(rulesDir, manifest) {
-  writeFileSync9(
-    toFsPath(join9(rulesDir, MANIFEST_FILE3)),
-    `${JSON.stringify(manifest, null, 2)}
+  writeFileSync8(
+    toFsPath(join9(docsDir, MANIFEST_FILE3)),
+    `${JSON.stringify(remoteManifest, null, 2)}
 `,
     "utf8"
   );
+  console.log(
+    `[apm] \u5DF2\u540C\u6B65\u9879\u76EE\u6587\u6863: projectId=${projectId} \u4E0B\u8F7D ${downloaded}\uFF0C\u5220\u9664\u672C\u5730 ${deleted} \u2192 .apm/project/${projectId}/`
+  );
+  return {
+    synced: true,
+    projectId,
+    downloaded,
+    deleted
+  };
 }
-function isBaseRuleFileName(fileName) {
-  return listBaseRuleFileNames().includes(basename3(fileName));
-}
-function isRuleUpToDate(entry, rule, dest) {
-  if (!entry || !existsSync7(toFsPath(dest))) return false;
-  if (entry.fileName !== ruleLocalFileName(rule.name)) return false;
-  const updatedAt = rule.updatedAt ?? "";
-  if (entry.updatedAt !== updatedAt) return false;
-  const localContent = readFileSync7(toFsPath(dest), "utf8");
-  return localContent === (rule.content ?? "");
-}
-async function syncPlatformRules(cfg, sessionId, workdirPath, apmRoot) {
+async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot, options) {
   const api = createApmApiClient(cfg);
-  const baseline = await resolveBranchBaseline(api, sessionId, workdirPath);
-  const repositoryId = baseline.repositoryId;
-  const rulesDir = join9(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 { projectId } = await resolveProjectIdForSync(
+    api,
+    workdirPath,
+    options
+  );
+  if (!projectId) {
+    return 0;
   }
-  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 = join9(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}`);
+  const targetApmDir = apmRoot ?? workspaceApmDir(workdirPath);
+  const localPaths = listLocalDocumentPaths(targetApmDir, projectId);
+  if (localPaths.length === 0) {
+    console.log("[apm] \u9879\u76EE\u6587\u6863\u65E0\u672C\u5730\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u63A8\u9001");
+    return 0;
+  }
+  const remoteManifest = (await api.cli.getProjectDocumentManifest({ projectId })).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 path19 of localPaths) {
+    const absPath = toFsPath(
+      projectDocumentLocalPath(targetApmDir, projectId, path19)
+    );
+    const content = readFileSync6(absPath, "utf8");
+    const contentHash = hashLocalFileContent(content);
+    if (remoteHashByPath.get(path19) === contentHash) {
       continue;
     }
-    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}`);
+    await api.cli.upsertProjectDocument({
+      projectId,
+      path: path19,
+      content,
+      description: remoteDescriptionByPath.get(path19) ?? void 0
+    });
+    synced += 1;
+    console.log(`[apm] \u5DF2\u540C\u6B65\u9879\u76EE\u6587\u6863: ${path19}`);
   }
-  const removed = [];
-  for (const [ruleId, entry] of Object.entries(manifest.rules)) {
-    if (remoteIds.has(ruleId)) continue;
-    if (isBaseRuleFileName(entry.fileName)) continue;
-    const dest = join9(rulesDir, entry.fileName);
-    if (existsSync7(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}`);
+  if (synced === 0) {
+    console.log("[apm] \u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
   }
-  saveManifest2(rulesDir, nextManifest);
-  return { written, skipped, removed, repositoryId };
+  return synced;
 }
 
 // src/commands/pull.ts
@@ -3012,20 +2883,20 @@ async function runPull(sessionId, remoteWorkdir) {
   const dir = sessionDir(trimmedId, apmRoot);
   const docsDir = sessionDocsDir(trimmedId, apmRoot);
   await ensureDirExists(docsDir);
-  writeFileSync10(
+  writeFileSync9(
     sessionRulePath(trimmedId, apmRoot),
     detail.description ?? "",
     "utf8"
   );
-  writeFileSync10(
+  writeFileSync9(
     sessionTaskPath(trimmedId, apmRoot),
     detail.task.description ?? "",
     "utf8"
   );
-  writeFileSync10(sessionTodoPath(trimmedId, apmRoot), detail.todo ?? "", "utf8");
+  writeFileSync9(sessionTodoPath(trimmedId, apmRoot), detail.todo ?? "", "utf8");
   for (const doc of documents) {
     const fileName = documentLocalFileName(doc.name);
-    writeFileSync10(join10(docsDir, fileName), doc.content ?? "", "utf8");
+    writeFileSync9(join10(docsDir, fileName), doc.content ?? "", "utf8");
   }
   const sessionYaml = yamlStringify(
     {
@@ -3042,13 +2913,13 @@ async function runPull(sessionId, remoteWorkdir) {
     },
     { lineWidth: 0 }
   );
-  writeFileSync10(
+  writeFileSync9(
     sessionYamlPath(trimmedId, apmRoot),
     sessionYaml.endsWith("\n") ? sessionYaml : `${sessionYaml}
 `,
     "utf8"
   );
-  writeFileSync10(
+  writeFileSync9(
     sessionMessagesXmlPath(trimmedId, apmRoot),
     formatSessionMessagesXml(trimmedId, messages),
     "utf8"
@@ -3065,7 +2936,7 @@ async function runPull(sessionId, remoteWorkdir) {
 import { spawnSync } from "child_process";
 
 // src/version.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname4, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var CLI_PACKAGE_NAME = "ai-project-manage-cli";
@@ -3073,7 +2944,7 @@ function readCliVersion() {
   try {
     const dir = dirname4(fileURLToPath2(import.meta.url));
     const pkgPath = join11(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -3328,7 +3199,7 @@ async function runSyncProjectDocuments(options) {
 }
 
 // src/commands/sync-document.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
 import { basename as basename4 } from "path";
 
 // src/assumptions/local-validate.ts
@@ -3499,7 +3370,7 @@ init_client();
 
 // src/commands/sync-session-documents.ts
 init_client();
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync8 } from "fs";
 import { join as join13 } from "path";
 function listLocalMarkdownFiles(docsDir) {
   if (!existsSync10(docsDir)) {
@@ -3518,7 +3389,7 @@ function remoteDocumentByLocalName(remoteDocuments, localFileName) {
 }
 async function upsertLocalDocumentFile(api, sessionId, docsDir, fileName) {
   const absPath = join13(docsDir, fileName);
-  const content = readFileSync9(absPath, "utf8");
+  const content = readFileSync8(absPath, "utf8");
   const name = documentPlatformName(absPath);
   return api.cli.upsertDocument({
     sessionId,
@@ -3541,7 +3412,7 @@ async function syncSessionDocuments(cfg, sessionId, apmRoot, options) {
   let synced = 0;
   for (const fileName of localFiles) {
     const absPath = join13(docsDir, fileName);
-    const content = readFileSync9(absPath, "utf8");
+    const content = readFileSync8(absPath, "utf8");
     const remote = remoteDocumentByLocalName(remoteDocuments, fileName);
     if (remote && remote.content === content) {
       continue;
@@ -3585,7 +3456,7 @@ async function runSyncDocument(sessionId, options) {
   const fileName = basename4(absPath);
   const assumptionSource = resolveAssumptionSourceFromFileName(fileName);
   if (assumptionSource) {
-    const content = readFileSync10(absPath, "utf8");
+    const content = readFileSync9(absPath, "utf8");
     const validation = validateAssumptionsMarkdown(content, assumptionSource);
     if (!validation.ok) {
       printAssumptionValidationResult(validation);
@@ -3948,7 +3819,7 @@ init_client();
 import path11 from "node:path";
 
 // src/commands/deploy/internal/apm-config.ts
-import { existsSync as existsSync13, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
 import { resolve as resolve5 } from "node:path";
 
 // src/commands/deploy/internal/config/config-validation.ts
@@ -4041,7 +3912,7 @@ function resolveFrontendDeployFromApmConfig(cfg) {
 }
 
 // src/commands/deploy/internal/config/maven-repo.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join14, resolve as resolve4 } from "node:path";
 var MAVEN_REPO_ENV_KEYS = [
@@ -4105,7 +3976,7 @@ function readMavenLocalRepoFromSettings() {
     return null;
   }
   try {
-    const xml = readFileSync11(settingsPath, "utf8");
+    const xml = readFileSync10(settingsPath, "utf8");
     const match = xml.match(
       /<localRepository>\s*([^<]+?)\s*<\/localRepository>/
     );
@@ -4241,7 +4112,7 @@ function loadApmConfig(options) {
     process.exit(1);
   }
   try {
-    const raw = readFileSync12(p, "utf8");
+    const raw = readFileSync11(p, "utf8");
     return JSON.parse(raw);
   } catch (e) {
     console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
@@ -4412,7 +4283,7 @@ import { dirname as dirname5, join as join17 } from "node:path";
 init_config();
 import { spawnSync as spawnSync2 } from "child_process";
 import { setTimeout as delay } from "node:timers/promises";
-import { existsSync as existsSync15, mkdirSync as mkdirSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { join as join16 } from "path";
 
 // src/commands/connect-lock.ts
@@ -4420,9 +4291,9 @@ init_config();
 import {
   existsSync as existsSync14,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync12,
   unlinkSync,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync10
 } from "fs";
 import { join as join15 } from "path";
 var CONNECT_LOCK_PATH = join15(APM_CONFIG_DIR, "connect.lock");
@@ -4454,7 +4325,7 @@ function waitForPm2LockHandoff(timeoutMs = 5e3) {
 function readConnectLock() {
   if (!existsSync14(CONNECT_LOCK_PATH)) return null;
   try {
-    const raw = readFileSync13(CONNECT_LOCK_PATH, "utf8");
+    const raw = readFileSync12(CONNECT_LOCK_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.pid !== "number" || parsed.mode !== "foreground" && parsed.mode !== "pm2" || typeof parsed.startedAt !== "string") {
       return null;
@@ -4495,7 +4366,7 @@ function acquireConnectLock(mode) {
     mode,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync11(
+  writeFileSync10(
     CONNECT_LOCK_PATH,
     JSON.stringify(lock, null, 2) + "\n",
     "utf8"
@@ -5009,7 +4880,7 @@ async function resolveBaseUrl(server) {
 }
 function writeConnectLaunchFiles(options) {
   mkdirSync7(APM_CONFIG_DIR, { recursive: true });
-  writeFileSync12(PM2_CONNECT_ENTRY_PATH, CONNECT_ENTRY_SCRIPT, "utf8");
+  writeFileSync11(PM2_CONNECT_ENTRY_PATH, CONNECT_ENTRY_SCRIPT, "utf8");
   const env = {
     ...collectPm2LaunchEnv()
   };
@@ -5024,7 +4895,7 @@ function writeConnectLaunchFiles(options) {
     cwd: options.cwd,
     env
   };
-  writeFileSync12(
+  writeFileSync11(
     PM2_CONNECT_LAUNCH_PATH,
     JSON.stringify(launch, null, 2) + "\n",
     "utf8"
@@ -5036,7 +4907,7 @@ function writeEcosystemFile(options) {
     entryScript: PM2_CONNECT_ENTRY_PATH,
     baseUrl: options.baseUrl
   });
-  writeFileSync12(
+  writeFileSync11(
     PM2_ECOSYSTEM_PATH,
     formatConnectPm2EcosystemFile(ecosystem),
     "utf8"
@@ -5457,7 +5328,7 @@ function logWisdomFrontendDeployContext(input) {
 }
 
 // src/commands/deploy/internal/wisdom-deploy.ts
-import { existsSync as existsSync21, readFileSync as readFileSync16, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync15, statSync as statSync10 } from "node:fs";
 import path10 from "node:path";
 
 // src/commands/deploy/deploy-shell-run.ts
@@ -5557,9 +5428,9 @@ import path9 from "node:path";
 import {
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync14,
   statSync as statSync8,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync13
 } from "node:fs";
 import path6 from "node:path";
 import JSZip2 from "jszip";
@@ -5568,9 +5439,9 @@ import JSZip2 from "jszip";
 import {
   existsSync as existsSync18,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync13,
   statSync as statSync7,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync12
 } from "node:fs";
 import path2 from "node:path";
 function deployCacheDir() {
@@ -5591,12 +5462,12 @@ function loadManifest3() {
   if (!existsSync18(manifestPath3)) {
     return {};
   }
-  return JSON.parse(readFileSync14(manifestPath3, "utf8"));
+  return JSON.parse(readFileSync13(manifestPath3, "utf8"));
 }
 function saveManifest3(manifest) {
   const dir = deployCacheDir();
   mkdirSync8(dir, { recursive: true });
-  writeFileSync13(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
+  writeFileSync12(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
 }
 function updateManifestEntries(manifest, entries, projectRoot) {
   for (const entry of entries) {
@@ -6010,7 +5881,7 @@ async function createUpdatePackage(entries, packageName) {
   log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path6.basename(zipPath)}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
   const zip = new JSZip2();
   for (const entry of entries) {
-    const content = readFileSync15(entry.path);
+    const content = readFileSync14(entry.path);
     zip.file(entry.arcname, content);
     log(`  \u6253\u5305: ${entry.arcname} (${entry.reason})`);
   }
@@ -6019,7 +5890,7 @@ async function createUpdatePackage(entries, packageName) {
     compression: "DEFLATE",
     compressionOptions: { level: 6 }
   });
-  writeFileSync14(zipPath, buffer);
+  writeFileSync13(zipPath, buffer);
   return zipPath;
 }
 function listAllLibFilesForArchive(libDir) {
@@ -6593,7 +6464,7 @@ function readPackageScripts(cwd) {
     return {};
   }
   try {
-    const raw = readFileSync16(pkgPath, "utf8");
+    const raw = readFileSync15(pkgPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.scripts ?? {};
   } catch {
@@ -7261,7 +7132,7 @@ import { resolve as resolve7 } from "node:path";
 import { getDefaultSdkStateRoot } from "@cursor/sdk";
 
 // src/commands/connect/webide-agent-registry.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync10, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "node:fs";
 import { dirname as dirname7, resolve as resolve6 } from "node:path";
 function registryPath(workdir, taskId) {
   return resolve6(workdir, ".apm", "webide", taskId, "cursor-agent.json");
@@ -7271,7 +7142,7 @@ function readRegistry(path19) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync17(path19, "utf8"));
+    const parsed = JSON.parse(readFileSync16(path19, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const raw = parsed;
       const state = {};
@@ -7756,7 +7627,7 @@ ${JSON.stringify(event, null, 2)}
 }
 
 // src/commands/connect/agent-session-registry.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync11, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync11, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "node:fs";
 import { dirname as dirname8, resolve as resolve8 } from "node:path";
 function registryPath2(workdir, sessionId) {
   return resolve8(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
@@ -7766,7 +7637,7 @@ function readRegistry2(path19) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync18(path19, "utf8"));
+    const parsed = JSON.parse(readFileSync17(path19, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const result = {};
       for (const [key, value] of Object.entries(
@@ -7784,7 +7655,7 @@ function readRegistry2(path19) {
 }
 function writeRegistry(path19, registry) {
   mkdirSync11(dirname8(path19), { recursive: true });
-  writeFileSync16(path19, `${JSON.stringify(registry, null, 2)}
+  writeFileSync15(path19, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function loadSessionAgentId(workdir, sessionId, user) {
@@ -8682,7 +8553,7 @@ async function ensureMessageHasReply(cfg, sessionId, messageId, fallback) {
 }
 
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync26, readFileSync as readFileSync19, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "fs";
 import { join as join19 } from "path";
 var CLI_VERSION_FILE = ".cli-version.json";
 function manifestPath2(apmDir) {
@@ -8695,7 +8566,7 @@ function loadManifest4(apmDir) {
   }
   try {
     const parsed = JSON.parse(
-      readFileSync19(path19, "utf8")
+      readFileSync18(path19, "utf8")
     );
     if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
       return parsed;
@@ -8706,7 +8577,7 @@ function loadManifest4(apmDir) {
 }
 function saveManifest4(apmDir, cliVersion) {
   const manifest = { version: 1, cliVersion };
-  writeFileSync17(
+  writeFileSync16(
     toFsPath(manifestPath2(apmDir)),
     `${JSON.stringify(manifest, null, 2)}
 `,
@@ -8983,13 +8854,7 @@ async function handleInboundMessage(cfg, msg, signal, ctx) {
   };
   try {
     if (signal.aborted) return;
-    const { didInit } = await runStep(
-      "workspace-init",
-      () => ensureWorkspaceInitialized(workdir)
-    );
-    if (!didInit) {
-      assertApmGitignoredInRepo(workdir);
-    }
+    await runStep("workspace-init", () => ensureWorkspaceInitialized(workdir));
     if (shouldRunBranch(msg.sessionId, workdir)) {
       if (signal.aborted) return;
       await runStep("branch", () => runBranch(msg.sessionId, { cwd: workdir }));
@@ -9862,7 +9727,7 @@ import path15 from "node:path";
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
-import { existsSync as existsSync27, readFileSync as readFileSync20 } from "node:fs";
+import { existsSync as existsSync27, readFileSync as readFileSync19 } from "node:fs";
 import path12 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
@@ -9875,7 +9740,7 @@ function asOptionalTlsBuffer(value) {
     return void 0;
   }
   if (existsSync27(normalized)) {
-    return readFileSync20(normalized);
+    return readFileSync19(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -10085,7 +9950,7 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync28, readFileSync as readFileSync21, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync20, statSync as statSync11 } from "node:fs";
 import path13 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
@@ -10105,7 +9970,7 @@ function loadEnvFromFile(envFilePath) {
   if (!existsSync28(targetPath) || !statSync11(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync21(targetPath, "utf-8");
+  const raw = readFileSync20(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -10686,9 +10551,7 @@ function buildProgram() {
   ).option("--api-key <key>", "\u5BA2\u6237\u673A API Key\uFF08cm_ \u5F00\u5934\uFF09").option("--server <url>", "API \u6839\u5730\u5740\uFF0C\u4F8B\u5982 http://127.0.0.1:3000").action(async (opts) => {
     await runLogin(opts);
   });
-  program.command("init").description(
-    "\u5728\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u521D\u59CB\u5316 .apm \u6A21\u677F\uFF08\u82E5 .apm \u5DF2\u5B58\u5728\u4E14\u975E\u7A7A\u5219\u62A5\u9519\uFF09\uFF1B\u5DF2\u767B\u5F55\u4E14\u5E73\u53F0\u6709\u5339\u914D\u90E8\u7F72\u914D\u7F6E\u65F6\u4F1A\u540C\u6B65 apm.config.json"
-  ).option("--name <name>", "\u5DE5\u4F5C\u76EE\u5F55\u540D\u79F0").action(async (opts) => {
+  program.command("init").description("\u5728\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u521B\u5EFA .apm \u5E76\u521D\u59CB\u5316\u6A21\u677F").option("--name <name>", "\u5DE5\u4F5C\u76EE\u5F55\u540D\u79F0").action(async (opts) => {
     await runInit(opts.name);
   });
   program.command("update").description(