ai-project-manage-cli 7.1.38 → 8.0.1

package/dist/webide-message-worker.js

@@ -14,52 +14,6 @@ var requestConfig = {
         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"
-    }),
-    getDevGate: defineEndpoint({
-      method: "GET",
-      path: "/cli/dev-gate"
-    }),
-    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"
-    }),
     webideAppendMessageContent: defineEndpoint({
       method: "PUT",
       path: "/cli/webide/messages/content"
@@ -120,44 +74,20 @@ var requestConfig = {
       method: "PUT",
       path: "/cli/webide/terminals/meta"
     }),
-    branchBaseline: defineEndpoint({
-      method: "GET",
-      path: "/cli/tasks/branch-baseline"
-    }),
     projectBaseBranch: defineEndpoint(
       {
         method: "GET",
         path: "/cli/tasks/project-base-branch"
       }
     ),
-    listSessionsForBranchCleanup: defineEndpoint({
-      method: "GET",
-      path: "/cli/sessions/branch-cleanup"
-    }),
     workspaceBaseline: defineEndpoint({
       method: "GET",
       path: "/cli/workspaces/baseline"
     }),
-    getDeploymentConfiguration: defineEndpoint({
-      method: "GET",
-      path: "/cli/deployment-configurations"
-    }),
     matchRepository: defineEndpoint({
       method: "GET",
       path: "/cli/repositories/match"
     }),
-    listSkills: defineEndpoint({
-      method: "GET",
-      path: "/cli/skills"
-    }),
-    listRules: defineEndpoint({
-      method: "GET",
-      path: "/cli/rules"
-    }),
-    createPullRequest: defineEndpoint({
-      method: "POST",
-      path: "/cli/pull-requests"
-    }),
     createWebIdeDraftPullRequest: defineEndpoint({
       method: "POST",
       path: "/cli/webide/draft-pull-requests"
@@ -338,6 +268,147 @@ function requireRemoteWorkdir(workdir) {
   return resolveWorkdirPath(trimmed);
 }
 
+// src/command-utils.ts
+import { copyFileSync, existsSync, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
+import { dirname, join as join2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var CLI_TEMPLATE_DIR = resolve2(__dirname, "../template");
+function workspaceApmDir(cwd = resolveWorkdirPath()) {
+  return resolve2(resolve2(cwd), ".apm");
+}
+function isWorkspaceApmInitialized(workdir) {
+  const apmDir = workspaceApmDir(workdir);
+  const fsApmDir = toFsPath(apmDir);
+  if (!existsSync(fsApmDir)) {
+    return false;
+  }
+  const st = statSync(fsApmDir);
+  if (!st.isDirectory()) {
+    throw new Error(
+      `\u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u4E0B\u7684 .apm \u4E0D\u662F\u76EE\u5F55\uFF0C\u8BF7\u68C0\u67E5\u672C\u5730\u63A5\u5165\u72B6\u6001\u3002`
+    );
+  }
+  return readdirSync(fsApmDir).length > 0;
+}
+var WEBIDE_SUBDIR = "webide";
+var WEBIDE_ATTACHMENTS_SUBDIR = "attachments";
+function webideTaskDir(taskId, workdir) {
+  return join2(workdir, ".apm", WEBIDE_SUBDIR, taskId);
+}
+function webideAttachmentsDir(taskId, workdir) {
+  return join2(webideTaskDir(taskId, workdir), WEBIDE_ATTACHMENTS_SUBDIR);
+}
+async function ensureLoggedConfig() {
+  const cfg = await ensureApmConfig();
+  if (!resolveApiKey(cfg)) {
+    console.error(
+      "[apm] \u672A\u68C0\u6D4B\u5230 API Key\uFF0C\u8BF7\u5148\u6267\u884C: apm login --api-key cm_xxx"
+    );
+    process.exit(1);
+  }
+  return cfg;
+}
+async function ensureDirExists(dir) {
+  mkdirSync2(dir, { recursive: true });
+}
+async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
+  const dir = workspaceApmDir(cwd);
+  const fsDir = toFsPath(dir);
+  if (existsSync(fsDir) && !statSync(fsDir).isDirectory()) {
+    throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${dir}`);
+  }
+  mkdirSync2(fsDir, { recursive: true });
+}
+var WEBIDE_AGENTS_TEMPLATE_NAME = "AGENTS.webide.md";
+function shouldSkipTemplateEntry(name) {
+  return name === ".DS_Store" || name === "Thumbs.db";
+}
+function isWebIdeRuleFileName(name) {
+  return name.startsWith("webide");
+}
+function copyTemplateEntry(src, dest) {
+  const fsSrc = toFsPath(src);
+  const fsDest = toFsPath(dest);
+  const st = statSync(fsSrc);
+  if (st.isDirectory()) {
+    mkdirSync2(fsDest, { recursive: true });
+    for (const name of readdirSync(fsSrc)) {
+      if (shouldSkipTemplateEntry(name)) continue;
+      copyTemplateEntry(join2(src, name), join2(dest, name));
+    }
+    return;
+  }
+  if (!st.isFile()) return;
+  mkdirSync2(toFsPath(dirname(dest)), { recursive: true });
+  copyFileSync(fsSrc, fsDest);
+}
+function listWebIdeRuleFileNames(rulesDir) {
+  const fsRulesDir = toFsPath(rulesDir);
+  if (!existsSync(fsRulesDir) || !statSync(fsRulesDir).isDirectory()) {
+    return [];
+  }
+  return readdirSync(fsRulesDir).filter((name) => {
+    if (shouldSkipTemplateEntry(name) || !isWebIdeRuleFileName(name)) {
+      return false;
+    }
+    return statSync(toFsPath(join2(rulesDir, name))).isFile();
+  });
+}
+function assertWebIdeTemplateCopiedToApm(apmDir, workdir) {
+  const required = ["AGENTS.md", "rules"];
+  for (const item of required) {
+    const path = join2(apmDir, item);
+    if (!existsSync(toFsPath(path))) {
+      throw new Error(`[apm] WebIDE \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path}`);
+    }
+  }
+  const rulesDir = join2(apmDir, "rules");
+  const ruleNames = listWebIdeRuleFileNames(rulesDir);
+  if (ruleNames.length === 0) {
+    throw new Error(`[apm] WebIDE \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11 webide \u89C4\u5219: ${rulesDir}`);
+  }
+  const leakedRules = join2(workdir, "rules");
+  const apmRules = join2(apmDir, "rules");
+  if (existsSync(toFsPath(leakedRules)) && !existsSync(toFsPath(join2(apmRules, "webide_reply.md")))) {
+    throw new Error(
+      `[apm] \u6A21\u677F\u88AB\u590D\u5236\u5230\u9519\u8BEF\u4F4D\u7F6E: ${leakedRules}\uFF08\u5E94\u5728 ${apmRules}\uFF09`
+    );
+  }
+}
+async function copyWebIdeTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
+  const resolvedTarget = resolve2(targetDir);
+  const templateDir = resolve2(CLI_TEMPLATE_DIR);
+  const fsTemplateDir = toFsPath(templateDir);
+  if (!existsSync(fsTemplateDir) || !statSync(fsTemplateDir).isDirectory()) {
+    throw new Error(`[apm] \u672A\u627E\u5230 CLI \u6A21\u677F\u76EE\u5F55: ${templateDir}`);
+  }
+  const agentsSrc = join2(templateDir, WEBIDE_AGENTS_TEMPLATE_NAME);
+  if (!existsSync(toFsPath(agentsSrc))) {
+    throw new Error(`[apm] \u672A\u627E\u5230 WebIDE \u6307\u5357: ${agentsSrc}`);
+  }
+  const rulesSrc = join2(templateDir, "rules");
+  const ruleNames = listWebIdeRuleFileNames(rulesSrc);
+  if (ruleNames.length === 0) {
+    throw new Error(`[apm] CLI \u6A21\u677F\u4E2D\u6CA1\u6709 webide \u89C4\u5219: ${rulesSrc}`);
+  }
+  mkdirSync2(toFsPath(resolvedTarget), { recursive: true });
+  copyFileSync(
+    toFsPath(agentsSrc),
+    toFsPath(join2(resolvedTarget, "AGENTS.md"))
+  );
+  const rulesDest = join2(resolvedTarget, "rules");
+  mkdirSync2(toFsPath(rulesDest), { recursive: true });
+  for (const name of ruleNames) {
+    copyTemplateEntry(join2(rulesSrc, name), join2(rulesDest, name));
+  }
+  assertWebIdeTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
+}
+
+// src/git-utils.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
 // src/git-remote.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -392,8 +463,6 @@ async function tryReadHttpsGitOriginUrl(cwd) {
 }
 
 // src/git-utils.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 function gitExecEnv() {
   const existing = process.env.GIT_SSH_COMMAND?.trim();
@@ -491,7 +560,7 @@ async function branchHasChangesAgainstBase(cwd, baseBranch, headBranch) {
     return true;
   }
 }
-var FEATURE_BRANCH_RE = /^feat\/(task|session)-.+/;
+var FEATURE_BRANCH_RE = /^feat\/task-.+/;
 function isFeatureBranchName(branch) {
   return FEATURE_BRANCH_RE.test(branch.trim().replace(/^origin\//, ""));
 }
@@ -601,132 +670,6 @@ async function pushCurrentBranch(cwd) {
   return true;
 }
 
-// src/command-utils.ts
-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";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var CLI_TEMPLATE_DIR = resolve2(__dirname, "../template");
-function workspaceApmDir(cwd = resolveWorkdirPath()) {
-  return resolve2(resolve2(cwd), ".apm");
-}
-function isWorkspaceApmInitialized(workdir) {
-  const apmDir = workspaceApmDir(workdir);
-  const fsApmDir = toFsPath(apmDir);
-  if (!existsSync(fsApmDir)) {
-    return false;
-  }
-  const st = statSync(fsApmDir);
-  if (!st.isDirectory()) {
-    throw new Error(
-      `\u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u4E0B\u7684 .apm \u4E0D\u662F\u76EE\u5F55\uFF0C\u8BF7\u68C0\u67E5\u672C\u5730\u63A5\u5165\u72B6\u6001\u3002`
-    );
-  }
-  return readdirSync(fsApmDir).length > 0;
-}
-var SESSION_ATTACHMENTS_SUBDIR = "attachments";
-var WEBIDE_SUBDIR = "webide";
-function webideTaskDir(taskId, workdir) {
-  return join2(workdir, ".apm", WEBIDE_SUBDIR, taskId);
-}
-function webideAttachmentsDir(taskId, workdir) {
-  return join2(webideTaskDir(taskId, workdir), SESSION_ATTACHMENTS_SUBDIR);
-}
-async function ensureLoggedConfig() {
-  const cfg = await ensureApmConfig();
-  if (!resolveApiKey(cfg)) {
-    console.error(
-      "[apm] \u672A\u68C0\u6D4B\u5230 API Key\uFF0C\u8BF7\u5148\u6267\u884C: apm login --api-key cm_xxx"
-    );
-    process.exit(1);
-  }
-  return cfg;
-}
-async function ensureDirExists(dir) {
-  mkdirSync2(dir, { recursive: true });
-}
-async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
-  const dir = workspaceApmDir(cwd);
-  const fsDir = toFsPath(dir);
-  if (existsSync(fsDir) && !statSync(fsDir).isDirectory()) {
-    throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${dir}`);
-  }
-  mkdirSync2(fsDir, { recursive: true });
-}
-var WORKSPACE_TEMPLATE_SUBDIRS = [
-  "sessions",
-  "skills",
-  "rules",
-  "deploy"
-];
-function shouldSkipTemplateEntry(name) {
-  return name === ".DS_Store" || name === "Thumbs.db";
-}
-function copyTemplateEntry(src, dest) {
-  const fsSrc = toFsPath(src);
-  const fsDest = toFsPath(dest);
-  const st = statSync(fsSrc);
-  if (st.isDirectory()) {
-    mkdirSync2(fsDest, { recursive: true });
-    for (const name of readdirSync(fsSrc)) {
-      if (shouldSkipTemplateEntry(name)) continue;
-      copyTemplateEntry(join2(src, name), join2(dest, name));
-    }
-    return;
-  }
-  if (!st.isFile()) return;
-  mkdirSync2(toFsPath(dirname(dest)), { recursive: true });
-  copyFileSync(fsSrc, fsDest);
-}
-function assertTemplateCopiedToApm(apmDir, workdir) {
-  const required = [
-    "AGENTS.md",
-    "apm.config.json",
-    "rules",
-    "skills",
-    "sessions"
-  ];
-  for (const item of required) {
-    const path = join2(apmDir, item);
-    if (!existsSync(toFsPath(path))) {
-      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path}`);
-    }
-  }
-  const leakedRules = join2(workdir, "rules");
-  const apmRules = join2(apmDir, "rules");
-  if (existsSync(toFsPath(leakedRules)) && !existsSync(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`
-    );
-  }
-}
-async function copyTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
-  const resolvedTarget = resolve2(targetDir);
-  const templateDir = resolve2(CLI_TEMPLATE_DIR);
-  const fsTemplateDir = toFsPath(templateDir);
-  if (!existsSync(fsTemplateDir)) {
-    throw new Error(`[apm] \u672A\u627E\u5230 CLI \u6A21\u677F\u76EE\u5F55: ${templateDir}`);
-  }
-  const dirStat = statSync(fsTemplateDir);
-  if (!dirStat.isDirectory()) {
-    throw new Error(`[apm] CLI \u6A21\u677F\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${templateDir}`);
-  }
-  const entries = readdirSync(fsTemplateDir).filter(
-    (name) => !shouldSkipTemplateEntry(name)
-  );
-  if (entries.length === 0) {
-    throw new Error(`[apm] CLI \u6A21\u677F\u76EE\u5F55\u4E3A\u7A7A: ${templateDir}`);
-  }
-  mkdirSync2(toFsPath(resolvedTarget), { recursive: true });
-  for (const name of entries) {
-    copyTemplateEntry(join2(templateDir, name), join2(resolvedTarget, name));
-  }
-  for (const subdir of WORKSPACE_TEMPLATE_SUBDIRS) {
-    mkdirSync2(toFsPath(join2(resolvedTarget, subdir)), { recursive: true });
-  }
-  assertTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
-}
-
 // src/workspace-repos.ts
 import {
   existsSync as existsSync2,
@@ -736,7 +679,7 @@ import {
   statSync as statSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename as basename2, dirname as dirname2, join as join3, relative, resolve as resolve3 } from "path";
+import { basename, dirname as dirname2, join as join3, relative, resolve as resolve3 } from "path";
 var WORKSPACE_REPOS_MANIFEST = "workspace-repos.json";
 var WORKSPACE_REPOS_VERSION = 1;
 var SKIP_DIR_NAMES = /* @__PURE__ */ new Set([".apm", "node_modules"]);
@@ -960,7 +903,7 @@ function resolveWorkspaceRepoAbsolutePaths(manifest) {
 }
 function formatRepoLabel(workdir, repoAbs) {
   const rel = toRelativeRepoPath(resolveWorkdirPath(workdir), repoAbs);
-  return rel === "." ? basename2(repoAbs) || repoAbs : rel;
+  return rel === "." ? basename(repoAbs) || repoAbs : rel;
 }
 
 // src/commands/branch.ts
@@ -1033,57 +976,47 @@ function branchNameForTask(taskId) {
 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}`
-      ]);
-    }
+  if (current === branch) {
+    console.log(`[apm] \u5DF2\u5728\u5206\u652F ${branch}\uFF0C\u8DF3\u8FC7`);
+    return branch;
   }
-  const onTargetBranch = await getCurrentBranch(gitRoot) === branch;
-  if (onTargetBranch) {
-    await execGit(gitRoot, ["fetch", "origin", baselineBranch]);
-    await execGit(gitRoot, ["merge", `origin/${baselineBranch}`, "--no-edit"]);
+  await ensureRemoteBaselineBranch(gitRoot, baselineBranch);
+  if (await isWorkingTreeDirty(gitRoot)) {
+    await execGit(gitRoot, [
+      "stash",
+      "push",
+      "-u",
+      "-m",
+      `apm: switch to ${branch}`
+    ]);
+  }
+  const remoteExists = await remoteBranchExists(gitRoot, branch);
+  if (remoteExists) {
+    await execGit(gitRoot, ["fetch", "origin", branch]);
+    await execGit(gitRoot, ["checkout", "-B", branch, `origin/${branch}`]);
+  } else if (await localBranchExists(gitRoot, branch)) {
+    await execGit(gitRoot, ["checkout", branch]);
+    console.log(`[apm] \u5206\u652F ${branch} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u521B\u5EFA`);
   } else {
-    const remoteExists = await remoteBranchExists(gitRoot, branch);
-    if (remoteExists) {
-      await execGit(gitRoot, ["fetch", "origin", branch]);
-      await execGit(gitRoot, ["checkout", "-B", branch, `origin/${branch}`]);
-    } else if (await localBranchExists(gitRoot, branch)) {
-      if (await getCurrentBranch(gitRoot) !== branch) {
-        await execGit(gitRoot, ["checkout", branch]);
-      }
-      console.log(`[apm] \u5206\u652F ${branch} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u521B\u5EFA`);
-    } else {
-      await execGit(gitRoot, ["fetch", "origin", baselineBranch]);
-      try {
-        await execGit(gitRoot, [
-          "checkout",
-          "-b",
-          branch,
-          `origin/${baselineBranch}`
-        ]);
-        await execGit(gitRoot, ["push", "-u", "origin", branch]);
-      } catch (err) {
-        if (await localBranchExists(gitRoot, branch)) {
-          if (await getCurrentBranch(gitRoot) !== branch) {
-            await execGit(gitRoot, ["checkout", branch]);
-          }
-          console.log(`[apm] \u5206\u652F ${branch} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u521B\u5EFA`);
-        } else {
-          throw err;
+    await execGit(gitRoot, ["fetch", "origin", baselineBranch]);
+    try {
+      await execGit(gitRoot, [
+        "checkout",
+        "-b",
+        branch,
+        `origin/${baselineBranch}`
+      ]);
+      await execGit(gitRoot, ["push", "-u", "origin", branch]);
+    } catch (err) {
+      if (await localBranchExists(gitRoot, branch)) {
+        if (await getCurrentBranch(gitRoot) !== branch) {
+          await execGit(gitRoot, ["checkout", branch]);
         }
+        console.log(`[apm] \u5206\u652F ${branch} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u521B\u5EFA`);
+      } else {
+        throw err;
       }
     }
   }
@@ -1102,9 +1035,7 @@ async function runTaskBranch(taskId, options = {}) {
   });
   const baselineBranch = projectBaseline.baseBranch?.trim() ?? "";
   if (!baselineBranch) {
-    throw new Error(
-      "[apm] \u9879\u76EE\u672A\u914D\u7F6E\u57FA\u7840\u5206\u652F\uFF0C\u65E0\u6CD5\u521B\u5EFA WebIDE \u7279\u6027\u5206\u652F"
-    );
+    throw new Error("[apm] \u9879\u76EE\u672A\u914D\u7F6E\u57FA\u7840\u5206\u652F\uFF0C\u65E0\u6CD5\u521B\u5EFA WebIDE \u7279\u6027\u5206\u652F");
   }
   const cwd = options.cwd ?? process.cwd();
   const workdirPath = resolveWorkdirPath(cwd);
@@ -1434,132 +1365,6 @@ ${JSON.stringify(event, null, 2)}
 \`\`\``;
 }
 
-// src/commands/connect/agent-session-registry.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, resolve as resolve4 } from "node:path";
-function registryPath(workdir, sessionId) {
-  return resolve4(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
-}
-function readRegistry(path) {
-  if (!existsSync3(path)) {
-    return {};
-  }
-  try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const result = {};
-      for (const [key, value] of Object.entries(
-        parsed
-      )) {
-        if (typeof value === "string" && value.trim()) {
-          result[key] = value.trim();
-        }
-      }
-      return result;
-    }
-  } catch {
-  }
-  return {};
-}
-function writeRegistry(path, registry) {
-  mkdirSync4(dirname3(path), { recursive: true });
-  writeFileSync3(path, `${JSON.stringify(registry, null, 2)}
-`, "utf8");
-}
-function loadSessionAgentId(workdir, sessionId, user) {
-  const registry = readRegistry(registryPath(workdir, sessionId));
-  return registry[user];
-}
-function saveSessionAgentId(workdir, sessionId, user, agentId) {
-  const path = registryPath(workdir, sessionId);
-  const registry = readRegistry(path);
-  registry[user] = agentId;
-  writeRegistry(path, registry);
-}
-function clearSessionAgentId(workdir, sessionId, user) {
-  const path = registryPath(workdir, sessionId);
-  const registry = readRegistry(path);
-  if (!(user in registry)) {
-    return;
-  }
-  delete registry[user];
-  writeRegistry(path, registry);
-}
-
-// src/commands/connect/cursor-message-log.ts
-var CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS = 2e3;
-function createThrottledCursorMessageLogSync(cfg, ctx, onError) {
-  let lastRunAt = 0;
-  let timer;
-  let latestSession;
-  let syncChain = Promise.resolve();
-  const syncDirtyEventsOnce = async (session) => {
-    const events = session.getDirtyEvents();
-    if (events.length === 0) {
-      return;
-    }
-    lastRunAt = Date.now();
-    try {
-      await syncCursorMessageLog(cfg, ctx, events);
-      session.clearDirtyIfUnchanged(events);
-    } catch (err) {
-      onError(err);
-    }
-  };
-  const drainDirtyEvents = async (session) => {
-    while (session.getDirtyEvents().length > 0) {
-      await syncDirtyEventsOnce(session);
-    }
-  };
-  const enqueueSync = (session) => {
-    syncChain = syncChain.then(() => drainDirtyEvents(session));
-  };
-  return {
-    schedule(session) {
-      latestSession = session;
-      const now = Date.now();
-      const elapsed = now - lastRunAt;
-      if (elapsed >= CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS) {
-        if (timer) {
-          clearTimeout(timer);
-          timer = void 0;
-        }
-        enqueueSync(session);
-        return;
-      }
-      if (timer) {
-        return;
-      }
-      timer = setTimeout(() => {
-        timer = void 0;
-        enqueueSync(latestSession);
-      }, CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS - elapsed);
-    },
-    async flush(session) {
-      latestSession = session;
-      if (timer) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-      await syncChain;
-      await drainDirtyEvents(session);
-    }
-  };
-}
-async function syncCursorMessageLog(cfg, ctx, events) {
-  const agentId = ctx.agentId.trim();
-  if (!agentId || events.length === 0) {
-    return;
-  }
-  const api = createApmApiClient(cfg);
-  await api.cli.upsertCursorMessageLog({
-    sessionId: ctx.sessionId,
-    messageId: ctx.messageId,
-    agentId,
-    events
-  });
-}
-
 // src/commands/connect/abort-signal-debug.ts
 import {
   getEventListeners,
@@ -1623,25 +1428,11 @@ ${stack}`
   );
 }
 
-// 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 });
-}
-
 // src/commands/connect/append-message-tool.ts
-function createAppendMessageCustomTools(cfg, messageId, appendContent2) {
-  const doAppend = appendContent2 ?? ((content) => appendMessageContent(cfg, messageId, content));
+function createAppendMessageCustomTools(messageId, appendContent2) {
   return {
     AppendMessage: {
-      description: "\u5411\u5F53\u524D\u4F1A\u8BDD/WebIDE \u6D88\u606F\u8FFD\u52A0\u7528\u6237\u53EF\u89C1\u56DE\u590D\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\u7ED3\u8BBA\u4E0E\u8FDB\u5C55\u5E94\u5199\u5728\u672C\u5DE5\u5177\u4E2D\uFF1B\u6700\u7EC8\u81EA\u7136\u8BED\u8A00\u6536\u5C3E\u52FF\u518D\u590D\u8FF0\u6B64\u5904\u5185\u5BB9\u3002",
+      description: "\u5411\u5F53\u524D WebIDE \u6D88\u606F\u8FFD\u52A0\u7528\u6237\u53EF\u89C1\u56DE\u590D\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\u7ED3\u8BBA\u4E0E\u8FDB\u5C55\u5E94\u5199\u5728\u672C\u5DE5\u5177\u4E2D\uFF1B\u6700\u7EC8\u81EA\u7136\u8BED\u8A00\u6536\u5C3E\u52FF\u518D\u590D\u8FF0\u6B64\u5904\u5185\u5BB9\u3002",
       inputSchema: {
         type: "object",
         properties: {
@@ -1661,7 +1452,7 @@ function createAppendMessageCustomTools(cfg, messageId, appendContent2) {
           };
         }
         try {
-          await doAppend(content);
+          await appendContent2(content);
           console.log(`[apm] AppendMessage \u5DF2\u8FFD\u52A0: messageId=${messageId}`);
           return "\u5DF2\u8FFD\u52A0\u6D88\u606F\u5185\u5BB9";
         } catch (err) {
@@ -2081,11 +1872,7 @@ var WORKSPACE_BOUNDARY_HINT = `[\u5DE5\u4F5C\u533A\u8FB9\u754C]
 \u7981\u6B62\u8BBF\u95EE\u5DE5\u4F5C\u533A\u5916\u8DEF\u5F84\uFF08\u5982\u5176\u5B83\u9879\u76EE\u3001~/.cursor\u3001agent-transcripts\u3001\u7CFB\u7EDF\u76EE\u5F55\u7B49\uFF09\u3002`;
 function createCursorCustomTools(cfg, messageId, options) {
   const tools = {
-    ...createAppendMessageCustomTools(
-      cfg,
-      messageId,
-      options?.appendMessageContent
-    ),
+    ...createAppendMessageCustomTools(messageId, options.appendMessageContent),
     AskQuestion: createAskQuestionTool({
       onInvoke: options?.onAskQuestion,
       execute: options?.askQuestionExecute
@@ -2145,11 +1932,6 @@ var noopRemoteLogSync = {
   async flush(_session) {
   }
 };
-var logCtx = (ctx, agentId) => ({
-  sessionId: ctx.sessionId,
-  messageId: ctx.messageId,
-  agentId
-});
 function formatCursorRunFailure(runId, options) {
   const details = [
     options?.statusError?.trim(),
@@ -2163,19 +1945,6 @@ function formatCursorRunFailure(runId, options) {
   }
   return `Cursor run \u5931\u8D25: ${runId} \u2014 ${details.join("\uFF1B")}`;
 }
-function persistSessionAgentId(ctx, agentId) {
-  if (ctx.skipSessionAgentRegistry || !ctx.user) return;
-  saveSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user, agentId);
-}
-function invalidatePersistedAgentId(ctx) {
-  if (ctx.skipSessionAgentRegistry) {
-    ctx.onInvalidatePersistedAgentId?.();
-    return;
-  }
-  if (ctx.user) {
-    clearSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user);
-  }
-}
 async function obtainAgent(ctx) {
   const agentOptions = {
     apiKey: ctx.apiKey,
@@ -2192,29 +1961,22 @@ async function obtainAgent(ctx) {
     ...ctx.mode ? { mode: ctx.mode } : {},
     ...ctx.mcpServers ? { mcpServers: ctx.mcpServers } : {}
   };
-  const explicitAgentId = ctx.resumeAgentId?.trim();
-  const savedAgentId = explicitAgentId || (!ctx.skipSessionAgentRegistry && ctx.user ? loadSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user) : void 0);
+  const savedAgentId = ctx.resumeAgentId?.trim();
   if (savedAgentId) {
     try {
       const agent = await Agent.resume(savedAgentId, agentOptions);
-      console.log(
-        `[apm] \u590D\u7528 Agent user=${ctx.user} agentId=${savedAgentId}${explicitAgentId ? "\uFF08\u53C2\u6570\u6307\u5B9A\uFF09" : ""}`
-      );
-      persistSessionAgentId(ctx, agent.agentId);
+      console.log(`[apm] \u590D\u7528 Agent user=${ctx.user} agentId=${savedAgentId}`);
       return { agent, resumed: true };
     } catch (err) {
       console.warn(
         `[apm] \u590D\u7528 Agent \u5931\u8D25\uFF08agentId=${savedAgentId}\uFF09\uFF0C\u56DE\u9000\u4E3A\u65B0\u5EFA:`,
         err instanceof Error ? err.message : err
       );
-      if (!explicitAgentId) {
-        invalidatePersistedAgentId(ctx);
-      }
+      ctx.onInvalidatePersistedAgentId?.();
     }
   }
   try {
     const agent = await Agent.create(agentOptions);
-    persistSessionAgentId(ctx, agent.agentId);
     return { agent, resumed: false };
   } catch (err) {
     if (ctx.enableSandbox && err instanceof Error && /sandbox/i.test(err.message)) {
@@ -2225,7 +1987,7 @@ async function obtainAgent(ctx) {
   }
 }
 async function runCursorAgent(cfg, ctx, options) {
-  const signal = options?.signal;
+  const signal = options.signal;
   logAbortSignalStats(signal, "runCursorAgent:start");
   if (signal?.aborted) {
     throw new Error("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u4EFB\u52A1\u4E2D\u65AD");
@@ -2236,54 +1998,36 @@ async function runCursorAgent(cfg, ctx, options) {
   }
   const workdir = resolveWorkdirPath(ctx.workdir);
   const customTools = createCursorCustomTools(cfg, ctx.messageId, {
-    onAskQuestion: options?.onAskQuestion,
-    appendMessageContent: options?.appendMessageContent,
-    askQuestionExecute: options?.askQuestionExecute,
-    enableWebIdePlanTools: options?.enableWebIdePlanTools,
-    taskId: options?.taskId,
+    onAskQuestion: options.onAskQuestion,
+    appendMessageContent: options.appendMessageContent,
+    askQuestionExecute: options.askQuestionExecute,
+    enableWebIdePlanTools: options.enableWebIdePlanTools,
+    taskId: options.taskId,
     workdir,
-    terminalRpc: options?.terminalRpc
+    terminalRpc: options.terminalRpc
   });
-  const enableSandbox = Boolean(options?.enableSandbox);
+  const enableSandbox = Boolean(options.enableSandbox);
   let prompt = withPlanModeToolHint(ctx.prompt, ctx.mode);
   prompt = withWorkspaceBoundaryHint(prompt);
   console.log(
-    `[apm] Cursor Agent \u5F00\u59CB messageId=${ctx.messageId} sessionId=${ctx.sessionId} cwd=${workdir} sandbox=${enableSandbox}`
+    `[apm] Cursor Agent \u5F00\u59CB messageId=${ctx.messageId} cwd=${workdir} sandbox=${enableSandbox}`
   );
   const { agent, resumed } = await obtainAgent({
     apiKey,
     model: ctx.model,
     cwd: workdir,
-    workdir,
-    sessionId: ctx.sessionId,
     user: ctx.user,
     mode: ctx.mode,
     resumeAgentId: ctx.resumeAgentId,
     customTools,
     enableSandbox,
-    skipSessionAgentRegistry: options?.skipSessionAgentRegistry,
-    onInvalidatePersistedAgentId: options?.onInvalidatePersistedAgentId
+    onInvalidatePersistedAgentId: options.onInvalidatePersistedAgentId
   });
   const invalidateAgentMapping = () => {
-    invalidatePersistedAgentId({
-      workdir,
-      sessionId: ctx.sessionId,
-      user: ctx.user,
-      skipSessionAgentRegistry: options?.skipSessionAgentRegistry,
-      onInvalidatePersistedAgentId: options?.onInvalidatePersistedAgentId
-    });
+    options.onInvalidatePersistedAgentId?.();
   };
-  const eventSession = options?.eventSession ?? new EventSession(prompt);
-  const syncRemoteLog = options?.createRemoteLogSync ? options.createRemoteLogSync(agent.agentId) : options?.skipRemoteLogSync ? noopRemoteLogSync : createThrottledCursorMessageLogSync(
-    cfg,
-    logCtx(ctx, agent.agentId),
-    (err) => {
-      console.warn(
-        "[apm] \u540C\u6B65 Cursor \u6D88\u606F\u65E5\u5FD7\u5931\u8D25:",
-        err instanceof Error ? err.message : err
-      );
-    }
-  );
+  const eventSession = options.eventSession ?? new EventSession(prompt);
+  const syncRemoteLog = options.createRemoteLogSync ? options.createRemoteLogSync(agent.agentId) : noopRemoteLogSync;
   let activeRun;
   const abortRun = () => {
     if (!activeRun?.supports("cancel")) return;
@@ -2295,14 +2039,14 @@ async function runCursorAgent(cfg, ctx, options) {
     const run = await agent.send(prompt, {
       ...ctx.mode ? { mode: ctx.mode } : {},
       local: {
-        ...options?.forceSend ? { force: true } : {},
+        ...options.forceSend ? { force: true } : {},
         customTools
       }
     });
     activeRun = run;
     logAbortSignalStats(signal, "runCursorAgent:after-send");
     console.log(`[apm] Cursor run id=${run.id} agentId=${agent.agentId}`);
-    await options?.onRunStarted?.({ agentId: agent.agentId, runId: run.id });
+    await options.onRunStarted?.({ agentId: agent.agentId, runId: run.id });
     let lastRunErrorStatus;
     for await (const event of run.stream()) {
       if (signal?.aborted) {
@@ -2318,7 +2062,7 @@ async function runCursorAgent(cfg, ctx, options) {
           );
         }
       }
-      options?.onStreamEvent?.(event);
+      options.onStreamEvent?.(event);
       eventSession.addEvent(event);
       syncRemoteLog.schedule(eventSession);
     }
@@ -2395,17 +2139,17 @@ async function runCursorAgent(cfg, ctx, options) {
 }
 
 // src/commands/connect/webide-agent-registry.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname4, resolve as resolve5 } from "node:path";
-function registryPath2(workdir, taskId) {
-  return resolve5(workdir, ".apm", "webide", taskId, "cursor-agent.json");
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, resolve as resolve4 } from "node:path";
+function registryPath(workdir, taskId) {
+  return resolve4(workdir, ".apm", "webide", taskId, "cursor-agent.json");
 }
-function readRegistry2(path) {
-  if (!existsSync4(path)) {
+function readRegistry(path) {
+  if (!existsSync3(path)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const raw = parsed;
       const state = {};
@@ -2433,16 +2177,16 @@ function readRegistry2(path) {
   }
   return {};
 }
-function writeRegistry2(path, registry) {
-  mkdirSync5(dirname4(path), { recursive: true });
-  writeFileSync4(path, `${JSON.stringify(registry, null, 2)}
+function writeRegistry(path, registry) {
+  mkdirSync4(dirname3(path), { recursive: true });
+  writeFileSync3(path, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function syncWebIdeTaskState(workdir, taskId, patch) {
   const trimmedTaskId = taskId.trim();
   if (!trimmedTaskId) return;
-  const path = registryPath2(workdir, trimmedTaskId);
-  const current = readRegistry2(path);
+  const path = registryPath(workdir, trimmedTaskId);
+  const current = readRegistry(path);
   const next = {
     ...current,
     taskId: trimmedTaskId,
@@ -2466,30 +2210,30 @@ function syncWebIdeTaskState(workdir, taskId, patch) {
   if (patch.status !== void 0) {
     next.status = patch.status;
   }
-  writeRegistry2(path, next);
+  writeRegistry(path, next);
 }
 function loadWebIdeAgentId(workdir, taskId) {
-  return readRegistry2(registryPath2(workdir, taskId)).agentId;
+  return readRegistry(registryPath(workdir, taskId)).agentId;
 }
 function saveWebIdeAgentId(workdir, taskId, agentId) {
   syncWebIdeTaskState(workdir, taskId, { agentId });
 }
 function clearWebIdeAgentId(workdir, taskId) {
-  const path = registryPath2(workdir, taskId);
-  if (!existsSync4(path)) return;
+  const path = registryPath(workdir, taskId);
+  if (!existsSync3(path)) return;
   syncWebIdeTaskState(workdir, taskId, { agentId: "" });
 }
 
 // src/commands/clean-webide-cache.ts
-import { existsSync as existsSync5, rmSync } from "node:fs";
-import { resolve as resolve6 } from "node:path";
+import { existsSync as existsSync4, rmSync } from "node:fs";
+import { resolve as resolve5 } from "node:path";
 import { getDefaultSdkStateRoot } from "@cursor/sdk";
 async function purgeCursorAgentStoreForAgent(workdir, agentId) {
   const trimmedAgentId = agentId.trim();
   const trimmedWorkdir = workdir.trim();
   if (!trimmedAgentId || !trimmedWorkdir) return false;
   const stateRoot = getDefaultSdkStateRoot(trimmedWorkdir);
-  if (!existsSync5(stateRoot)) return false;
+  if (!existsSync4(stateRoot)) return false;
   const { SqliteLocalAgentStore } = await import(
     /* @vite-ignore */
     "@cursor/sdk/sqlite"
@@ -2553,8 +2297,8 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir) {
       `[apm] \u65E0 WebIDE agentId\uFF0C\u8DF3\u8FC7 agent store \u6E05\u7406 taskId=${trimmedTaskId}`
     );
   }
-  const dir = resolve6(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
-  if (existsSync5(dir)) {
+  const dir = resolve5(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
+  if (existsSync4(dir)) {
     rmSync(dir, { recursive: true, force: true });
     console.log(`[apm] \u5DF2\u6E05\u7406 WebIDE \u7F13\u5B58 ${dir}`);
   } else {
@@ -2676,14 +2420,14 @@ var MinioClient = class {
   async deleteObjectsByPrefix(bucket, prefix) {
     const objectsStream = this.inner.listObjectsV2(bucket, prefix, true);
     const keys = [];
-    await new Promise((resolve7, reject) => {
+    await new Promise((resolve6, reject) => {
       objectsStream.on("data", (obj) => {
         if (obj.name) {
           keys.push(obj.name);
         }
       });
       objectsStream.on("error", reject);
-      objectsStream.on("end", resolve7);
+      objectsStream.on("end", resolve6);
     });
     const chunkSize = 500;
     for (let i = 0; i < keys.length; i += chunkSize) {
@@ -2872,48 +2616,33 @@ function resolveMessageReplyFallback(fallback) {
 }
 
 // src/commands/init.ts
-import { join as join4 } from "path";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
-async function initializeWorkspace(workdir, options) {
+async function initializeWorkspace(workdir) {
   await ensureWorkspaceApmDirForInit(workdir);
   const apmDir = workspaceApmDir(workdir);
-  await copyTemplateFiles(apmDir, workdir);
-  const trimmedName = options?.name?.trim();
-  if (trimmedName) {
-    const apmConfigPath = toFsPath(join4(apmDir, "apm.config.json"));
-    const config = readFileSync5(apmConfigPath, "utf8");
-    const configJson = JSON.parse(config);
-    configJson.name = trimmedName;
-    writeFileSync5(
-      apmConfigPath,
-      `${JSON.stringify(configJson, null, 2)}
-`,
-      "utf8"
-    );
-  }
-  console.log(`[apm] \u5DF2\u521D\u59CB\u5316\u5DE5\u4F5C\u533A\uFF1A${apmDir}`);
+  await copyWebIdeTemplateFiles(apmDir, workdir);
+  console.log(`[apm] \u5DF2\u6309 WebIDE \u521D\u59CB\u5316\u5DE5\u4F5C\u533A\uFF1A${apmDir}`);
   return { didInit: true };
 }
-async function ensureWorkspaceInitialized(workdir, options) {
+async function ensureWorkspaceInitialized(workdir) {
   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`
+    `[apm] \u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u672A\u68C0\u6D4B\u5230\u5DF2\u521D\u59CB\u5316\u7684 .apm\uFF0C\u6B63\u5728\u6309 WebIDE \u81EA\u52A8\u521D\u59CB\u5316\u2026`
   );
-  return initializeWorkspace(workdir, options);
+  return initializeWorkspace(workdir);
 }
 
 // src/commands/connect/pre-step-cache.ts
-function sessionWorkdirKey(sessionId, workdir) {
-  return `${sessionId}\0${workdir}`;
+function taskWorkdirKey(taskId, workdir) {
+  return `${taskId}\0${workdir}`;
 }
 var lastBranchKey = null;
-function shouldRunBranch(sessionId, workdir) {
-  return lastBranchKey !== sessionWorkdirKey(sessionId, workdir);
+function shouldRunBranch(taskId, workdir) {
+  return lastBranchKey !== taskWorkdirKey(taskId, workdir);
 }
-function markBranchDone(sessionId, workdir) {
-  lastBranchKey = sessionWorkdirKey(sessionId, workdir);
+function markBranchDone(taskId, workdir) {
+  lastBranchKey = taskWorkdirKey(taskId, workdir);
 }
 
 // src/commands/connect/webide-pull-requests.ts
@@ -3035,7 +2764,7 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
     try {
       const current = await getCurrentBranch(gitRoot);
       if (!isFeatureBranchName(current)) {
-        const tip = `${label}\uFF1A\u5F53\u524D\u5206\u652F ${current} \u4E0D\u662F feat/task-* / feat/session-*\uFF0C\u4E0D\u7B26\u5408\u521B\u5EFA PR \u6761\u4EF6`;
+        const tip = `${label}\uFF1A\u5F53\u524D\u5206\u652F ${current} \u4E0D\u662F feat/task-*\uFF0C\u4E0D\u7B26\u5408\u521B\u5EFA PR \u6761\u4EF6`;
         console.warn(`[apm] WebIDE PR\uFF1A${tip}`);
         tips.push(tip);
         skipped += 1;
@@ -3153,164 +2882,23 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname5, join as join5 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function readCliVersion() {
   try {
-    const dir = dirname5(fileURLToPath2(import.meta.url));
-    const pkgPath = join5(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+    const dir = dirname4(fileURLToPath2(import.meta.url));
+    const pkgPath = join4(dir, "..", "package.json");
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 
-// src/commands/update-skills.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, statSync as statSync4 } from "fs";
-import { join as join7 } from "path";
-
-// src/skills-sync.ts
-import {
-  copyFileSync as copyFileSync2,
-  cpSync,
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync6,
-  readdirSync as readdirSync3,
-  rmSync as rmSync2,
-  statSync as statSync3,
-  writeFileSync as writeFileSync6
-} from "fs";
-import { join as join6 } from "path";
-var AGENTS_TEMPLATE_PATH = join6(CLI_TEMPLATE_DIR, "AGENTS.md");
-var BASE_SKILLS_TEMPLATE_DIR = join6(CLI_TEMPLATE_DIR, "skills");
-var BASE_RULES_TEMPLATE_DIR = join6(CLI_TEMPLATE_DIR, "rules");
-function sanitizeSkillDirName(name) {
-  const trimmed = name.trim();
-  if (!trimmed) return "skill";
-  return trimmed.replace(/[/\\:*?"<>|]/g, "_");
-}
-function listBaseSkillDirNames() {
-  if (!existsSync6(BASE_SKILLS_TEMPLATE_DIR)) return [];
-  return readdirSync3(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
-    const path = join6(BASE_SKILLS_TEMPLATE_DIR, name);
-    return statSync3(path).isDirectory();
-  });
-}
-function syncAgentsGuide(apmDir) {
-  if (!existsSync6(AGENTS_TEMPLATE_PATH)) return false;
-  mkdirSync6(apmDir, { recursive: true });
-  copyFileSync2(AGENTS_TEMPLATE_PATH, join6(apmDir, "AGENTS.md"));
-  return true;
-}
-function listBaseRuleFileNames() {
-  if (!existsSync6(BASE_RULES_TEMPLATE_DIR)) return [];
-  return readdirSync3(BASE_RULES_TEMPLATE_DIR).filter((name) => {
-    const path = join6(BASE_RULES_TEMPLATE_DIR, name);
-    return statSync3(path).isFile();
-  });
-}
-function syncBaseRules(rulesDir) {
-  mkdirSync6(rulesDir, { recursive: true });
-  const names = listBaseRuleFileNames();
-  for (const name of names) {
-    const src = join6(BASE_RULES_TEMPLATE_DIR, name);
-    const dest = join6(rulesDir, name);
-    copyFileSync2(src, dest);
-  }
-  return names;
-}
-function syncBaseSkills(skillsDir) {
-  mkdirSync6(skillsDir, { recursive: true });
-  const names = listBaseSkillDirNames();
-  for (const name of names) {
-    const src = join6(BASE_SKILLS_TEMPLATE_DIR, name);
-    const dest = join6(skillsDir, name);
-    cpSync(src, dest, { recursive: true, force: true });
-  }
-  return names;
-}
-function syncSupplementarySkills(skillsDir, list) {
-  const baseNames = new Set(listBaseSkillDirNames());
-  const apiDirNames = /* @__PURE__ */ new Set();
-  const written = [];
-  const skipped = [];
-  for (const skill of list) {
-    const dirName = sanitizeSkillDirName(skill.name);
-    apiDirNames.add(dirName);
-    if (baseNames.has(dirName)) {
-      skipped.push(dirName);
-      continue;
-    }
-    const skillDir = join6(skillsDir, dirName);
-    mkdirSync6(skillDir, { recursive: true });
-    writeFileSync6(join6(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
-    written.push(dirName);
-  }
-  const removed = [];
-  if (!existsSync6(skillsDir)) return { written, skipped, removed };
-  for (const entry of readdirSync3(skillsDir)) {
-    const full = join6(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);
-  }
-  return { written, skipped, removed };
-}
-
-// src/commands/update-skills.ts
-async function syncWorkspaceSkills(cfg, workdir) {
-  const apmDir = workspaceApmDir(workdir);
-  const fsApmDir = toFsPath(apmDir);
-  if (!existsSync7(fsApmDir)) {
-    throw new Error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
-  }
-  const apmStat = statSync4(fsApmDir);
-  if (!apmStat.isDirectory()) {
-    throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${apmDir}`);
-  }
-  const api = createApmApiClient(cfg);
-  const { list } = await api.cli.listSkills({});
-  if (syncAgentsGuide(apmDir)) {
-    console.log("[apm] \u5DF2\u540C\u6B65 APM \u6307\u5357: .apm/AGENTS.md");
-  }
-  const rulesDir = join7(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 = join7(apmDir, "skills");
-  mkdirSync7(toFsPath(skillsDir), { recursive: true });
-  const baseNames = syncBaseSkills(skillsDir);
-  for (const name of baseNames) {
-    console.log(`[apm] \u5DF2\u540C\u6B65\u57FA\u7840\u6280\u80FD: skills/${name}/`);
-  }
-  const { written, skipped, removed } = syncSupplementarySkills(
-    skillsDir,
-    list
-  );
-  for (const name of written) {
-    console.log(`[apm] \u5DF2\u5199\u5165\u8865\u5145\u6280\u80FD: skills/${name}/SKILL.md`);
-  }
-  for (const name of skipped) {
-    console.log(
-      `[apm] \u5DF2\u8DF3\u8FC7\u4E0E\u57FA\u7840\u6280\u80FD\u540C\u540D\u7684\u8865\u5145\u6280\u80FD: ${name}\uFF08\u4FDD\u7559\u6A21\u677F\u7248\u672C\uFF09`
-    );
-  }
-  for (const name of removed) {
-    console.log(`[apm] \u5DF2\u79FB\u9664\u5DF2\u4E0B\u7EBF\u7684\u8865\u5145\u6280\u80FD: skills/${name}/`);
-  }
-  console.log(
-    `[apm] \u540C\u6B65\u5B8C\u6210\uFF1A${ruleNames.length} \u4E2A\u57FA\u7840\u89C4\u5219\uFF0C${baseNames.length} \u4E2A\u57FA\u7840\u6280\u80FD\uFF0C${written.length} \u4E2A\u8865\u5145\u6280\u80FD`
-  );
-}
-
-// src/commands/sync-session-attachments.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
-import { join as join8 } from "path";
+// src/commands/sync-webide-attachments.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
 var MANIFEST_FILE = ".sync-manifest.json";
 async function downloadAttachment(cfg, attachmentId) {
   const base = cfg.baseUrl.trim().replace(/\/+$/, "");
@@ -3326,13 +2914,13 @@ async function downloadAttachment(cfg, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path = join8(dir, MANIFEST_FILE);
-  if (!existsSync8(path)) {
+  const path = join5(dir, MANIFEST_FILE);
+  if (!existsSync5(path)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync7(path, "utf8")
+      readFileSync5(path, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -3342,15 +2930,15 @@ function loadManifest(dir) {
   return { version: 1, attachments: {} };
 }
 function saveManifest(dir, manifest) {
-  writeFileSync7(
-    join8(dir, MANIFEST_FILE),
+  writeFileSync4(
+    join5(dir, MANIFEST_FILE),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
 function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync8(dest)) return false;
+  if (!entry || !existsSync5(dest)) return false;
   if (entry.name !== item.name) return false;
   const createdAt = item.createdAt ?? "";
   return entry.createdAt === createdAt;
@@ -3365,7 +2953,7 @@ async function syncAttachmentsToDirectory(cfg, attachments, dir, logLabel) {
   const nextManifest = { version: 1, attachments: {} };
   const names = [];
   for (const item of attachments) {
-    const dest = join8(dir, item.name);
+    const dest = join5(dir, item.name);
     const entry = manifest.attachments[item.id];
     const createdAt = item.createdAt ?? "";
     names.push(item.name);
@@ -3375,7 +2963,7 @@ async function syncAttachmentsToDirectory(cfg, attachments, dir, logLabel) {
       continue;
     }
     const buffer = await downloadAttachment(cfg, item.id);
-    writeFileSync7(dest, buffer);
+    writeFileSync4(dest, buffer);
     nextManifest.attachments[item.id] = {
       name: item.name,
       createdAt
@@ -3397,14 +2985,14 @@ async function syncWebIdeAttachments(cfg, taskId, workdir, attachments) {
 
 // src/project-documents-sync.ts
 import {
-  existsSync as existsSync9,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync8,
-  rmSync as rmSync3,
-  writeFileSync as writeFileSync8
+  existsSync as existsSync6,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync6,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync5
 } from "fs";
 import { createHash } from "crypto";
-import { dirname as dirname6, join as join9, relative as relative2, sep } from "path";
+import { dirname as dirname5, join as join6, relative as relative2, sep } from "path";
 var MANIFEST_FILE2 = "manifest.json";
 function normalizeProjectIdForPath(projectId) {
   const id = projectId.trim();
@@ -3418,11 +3006,11 @@ function normalizeProjectIdForPath(projectId) {
 }
 function projectDocumentsDir(apmRoot, projectId) {
   const id = normalizeProjectIdForPath(projectId);
-  return join9(apmRoot ?? workspaceApmDir(), "project", id);
+  return join6(apmRoot ?? workspaceApmDir(), "project", id);
 }
 function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
-  return join9(
+  return join6(
     projectDocumentsDir(apmRoot, projectId),
     ...normalized.split("/")
   );
@@ -3442,16 +3030,16 @@ function hashLocalFileContent(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 function readLocalManifest(apmRoot, projectId) {
-  const manifestPath3 = join9(
+  const manifestPath3 = join6(
     projectDocumentsDir(apmRoot, projectId),
     MANIFEST_FILE2
   );
-  if (!existsSync9(manifestPath3)) {
+  if (!existsSync6(manifestPath3)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync8(manifestPath3, "utf8")
+      readFileSync6(manifestPath3, "utf8")
     );
   } catch {
     return null;
@@ -3459,13 +3047,13 @@ function readLocalManifest(apmRoot, projectId) {
 }
 function listLocalDocumentPaths(apmRoot, projectId) {
   const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync9(root)) {
+  if (!existsSync6(root)) {
     return [];
   }
   const paths = [];
   const walk = (dir) => {
-    for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-      const abs = join9(dir, entry.name);
+    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      const abs = join6(dir, entry.name);
       if (entry.isDirectory()) {
         walk(abs);
         continue;
@@ -3583,8 +3171,8 @@ ${diagnostic ?? ""}`);
       const absPath = toFsPath(
         projectDocumentLocalPath(targetApmDir, projectId, doc.path)
       );
-      await ensureDirExists(dirname6(absPath));
-      writeFileSync8(absPath, doc.content, "utf8");
+      await ensureDirExists(dirname5(absPath));
+      writeFileSync5(absPath, doc.content, "utf8");
       downloaded += 1;
     }
   }
@@ -3593,13 +3181,13 @@ ${diagnostic ?? ""}`);
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path)
     );
-    if (existsSync9(absPath)) {
-      rmSync3(absPath, { force: true });
+    if (existsSync6(absPath)) {
+      rmSync2(absPath, { force: true });
       deleted += 1;
     }
   }
-  writeFileSync8(
-    toFsPath(join9(docsDir, MANIFEST_FILE2)),
+  writeFileSync5(
+    toFsPath(join6(docsDir, MANIFEST_FILE2)),
     `${JSON.stringify(remoteManifest, null, 2)}
 `,
     "utf8"
@@ -3642,7 +3230,7 @@ async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot, options) {
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path)
     );
-    const content = readFileSync8(absPath, "utf8");
+    const content = readFileSync6(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
     if (remoteHashByPath.get(path) === contentHash) {
       continue;
@@ -3663,20 +3251,20 @@ async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot, options) {
 }
 
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join7 } from "path";
 var CLI_VERSION_FILE = ".cli-version.json";
 function manifestPath2(apmDir) {
-  return join10(apmDir, CLI_VERSION_FILE);
+  return join7(apmDir, CLI_VERSION_FILE);
 }
 function loadManifest2(apmDir) {
   const path = toFsPath(manifestPath2(apmDir));
-  if (!existsSync10(path)) {
+  if (!existsSync7(path)) {
     return null;
   }
   try {
     const parsed = JSON.parse(
-      readFileSync9(path, "utf8")
+      readFileSync7(path, "utf8")
     );
     if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
       return parsed;
@@ -3687,7 +3275,7 @@ function loadManifest2(apmDir) {
 }
 function saveManifest2(apmDir, cliVersion) {
   const manifest = { version: 1, cliVersion };
-  writeFileSync9(
+  writeFileSync6(
     toFsPath(manifestPath2(apmDir)),
     `${JSON.stringify(manifest, null, 2)}
 `,
@@ -3747,7 +3335,7 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
   const workdir = requireRemoteWorkdir(msg.workdir);
   const messageId = msg.messageId;
   const taskId = msg.taskId;
-  const branchCacheKey = `webide:${taskId}`;
+  const branchCacheKey = taskId;
   console.log(
     `[apm] webide-message action=${msg.action} taskId=${taskId} messageId=${messageId}`
   );
@@ -3802,9 +3390,9 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
     if (shouldSyncSkillsForCliVersion(workdir, cliVersion)) {
       if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
       await runPrepStep(
-        "\u540C\u6B65 Skills",
+        "\u540C\u6B65 WebIDE \u89C4\u5219",
         async () => {
-          await syncWorkspaceSkills(cfg, workdir);
+          await copyWebIdeTemplateFiles(workspaceApmDir(workdir), workdir);
           markSkillsSyncedForCliVersion(workdir, cliVersion);
           return cliVersion;
         },
@@ -3812,7 +3400,7 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
       );
     } else {
       eventSession.addCliStep(
-        "\u540C\u6B65 Skills",
+        "\u540C\u6B65 WebIDE \u89C4\u5219",
         `\u7248\u672C\u4E00\u81F4\uFF08${cliVersion}\uFF09\uFF0C\u8DF3\u8FC7`,
         "skip"
       );
@@ -3937,7 +3525,6 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
       cfg,
       {
         messageId,
-        sessionId: `webide:${taskId}`,
         prompt: msg.content,
         model: msg.model,
         apiKey: msg.apiKey,
@@ -3957,7 +3544,6 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
         }),
         enableWebIdePlanTools: true,
         enableSandbox: false,
-        skipSessionAgentRegistry: true,
         onInvalidatePersistedAgentId: () => clearWebIdeAgentId(workdir, taskId),
         taskId,
         terminalRpc: options?.terminalRpc,
@@ -4168,12 +3754,12 @@ function installTerminalRpcListener() {
 }
 function call(op, args) {
   const id = nextId++;
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve6, reject) => {
     if (!parentPort) {
       reject(new Error("parentPort \u4E0D\u53EF\u7528"));
       return;
     }
-    pending.set(id, { resolve: resolve7, reject });
+    pending.set(id, { resolve: resolve6, reject });
     parentPort.postMessage({
       type: "terminal-rpc",
       id,