ai-project-manage-cli 7.1.39 → 8.0.2

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,16 @@ 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"
@@ -182,22 +108,6 @@ var requestConfig = {
       method: "DELETE",
       path: "/cli/project-documents"
     }),
-    createTaskDeployment: defineEndpoint({
-      method: "POST",
-      path: "/cli/task-deployments"
-    }),
-    updateTaskDeploymentStatus: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/status"
-    }),
-    syncTaskDeploymentLog: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/log"
-    }),
-    completeTaskDeployment: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/complete"
-    }),
     getDeployArtifactStorage: defineEndpoint(
       {
         method: "GET",
@@ -207,10 +117,6 @@ var requestConfig = {
     getApmLogStorage: defineEndpoint({
       method: "GET",
       path: "/cli/apm-log-storage"
-    }),
-    attachTaskDeploymentArtifact: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/artifact"
     })
   }
 };
@@ -338,6 +244,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 +439,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();
@@ -474,323 +519,50 @@ async function branchHasChangesAgainstBase(cwd, baseBranch, headBranch) {
   let headRef = head;
   try {
     await execGit(cwd, ["fetch", "origin", head], true);
-    await execGit(cwd, ["rev-parse", "--verify", `origin/${head}`], true);
-    headRef = `origin/${head}`;
-  } catch {
-    await execGit(cwd, ["rev-parse", "--verify", head], true);
-  }
-  const baseRef = `origin/${base}`;
-  const ahead = (await execGit(cwd, ["rev-list", "--count", `${baseRef}..${headRef}`], true)).trim();
-  if ((Number.parseInt(ahead, 10) || 0) <= 0) {
-    return false;
-  }
-  try {
-    await execGit(cwd, ["diff", "--quiet", `${baseRef}...${headRef}`], true);
-    return false;
-  } catch {
-    return true;
-  }
-}
-var FEATURE_BRANCH_RE = /^feat\/(task|session)-.+/;
-function isFeatureBranchName(branch) {
-  return FEATURE_BRANCH_RE.test(branch.trim().replace(/^origin\//, ""));
-}
-async function resolveFeatureBranchBaseFromGit(cwd, headBranch) {
-  const head = headBranch.trim().replace(/^origin\//, "");
-  if (!head) {
-    throw new Error("[apm] head \u5206\u652F\u540D\u4E3A\u7A7A\uFF0C\u65E0\u6CD5\u63A8\u65AD\u57FA\u7EBF");
-  }
-  try {
-    const reflog = await execGit(
-      cwd,
-      ["reflog", "show", "--date=iso", head],
-      true
-    );
-    for (const line of reflog.split("\n")) {
-      const created = line.match(
-        /Created from (?:refs\/remotes\/origin\/|origin\/)?(\S+)/i
-      );
-      if (created?.[1]) {
-        const name = created[1].replace(/^origin\//, "");
-        if (name && name !== head && !isFeatureBranchName(name)) {
-          return name;
-        }
-      }
-      const moving = line.match(
-        /checkout: moving from (\S+) to (?:origin\/)?\S+/i
-      );
-      if (moving?.[1]) {
-        const from = moving[1].replace(/^origin\//, "");
-        if (from && from !== head && !isFeatureBranchName(from)) {
-          return from;
-        }
-      }
-    }
-  } catch {
-  }
-  await execGit(cwd, ["fetch", "origin", "--prune"], true);
-  let headRef = head;
-  try {
-    await execGit(cwd, ["rev-parse", "--verify", `origin/${head}`], true);
-    headRef = `origin/${head}`;
-  } catch {
-    await execGit(cwd, ["rev-parse", "--verify", head], true);
-  }
-  const refsOut = await execGit(
-    cwd,
-    ["for-each-ref", "--format=%(refname:short)", "refs/remotes/origin/"],
-    true
-  );
-  let best = null;
-  for (const ref of refsOut.split("\n").map((s) => s.trim()).filter(Boolean)) {
-    const name = ref.replace(/^origin\//, "");
-    if (!name || name === "HEAD" || name === head || isFeatureBranchName(name)) {
-      continue;
-    }
-    try {
-      await execGit(
-        cwd,
-        ["merge-base", "--is-ancestor", `origin/${name}`, headRef],
-        true
-      );
-      const ahead = Number.parseInt(
-        (await execGit(
-          cwd,
-          ["rev-list", "--count", `origin/${name}..${headRef}`],
-          true
-        )).trim(),
-        10
-      );
-      if (!Number.isFinite(ahead) || ahead < 0) continue;
-      if (!best || ahead < best.ahead) {
-        best = { name, ahead };
-      }
-    } catch {
-      continue;
-    }
-  }
-  if (best) {
-    return best.name;
-  }
-  throw new Error(
-    `[apm] \u65E0\u6CD5\u63A8\u65AD ${head} \u57FA\u4E8E\u54EA\u6761\u5206\u652F\u521B\u5EFA\uFF0C\u8BF7\u786E\u8BA4\u672C\u5730 reflog \u6216 origin \u8FDC\u7A0B\u5206\u652F`
-  );
-}
-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;
-}
-
-// 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"
-];
-var WEBIDE_AGENTS_TEMPLATE_NAME = "AGENTS.webide.md";
-function shouldSkipTemplateEntry(name) {
-  return name === ".DS_Store" || name === "Thumbs.db" || name === WEBIDE_AGENTS_TEMPLATE_NAME;
-}
-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 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}`);
+    await execGit(cwd, ["rev-parse", "--verify", `origin/${head}`], true);
+    headRef = `origin/${head}`;
+  } catch {
+    await execGit(cwd, ["rev-parse", "--verify", head], true);
   }
-  mkdirSync2(toFsPath(resolvedTarget), { recursive: true });
-  for (const name of entries) {
-    copyTemplateEntry(join2(templateDir, name), join2(resolvedTarget, name));
+  const baseRef = `origin/${base}`;
+  const ahead = (await execGit(cwd, ["rev-list", "--count", `${baseRef}..${headRef}`], true)).trim();
+  if ((Number.parseInt(ahead, 10) || 0) <= 0) {
+    return false;
   }
-  for (const subdir of WORKSPACE_TEMPLATE_SUBDIRS) {
-    mkdirSync2(toFsPath(join2(resolvedTarget, subdir)), { recursive: true });
+  try {
+    await execGit(cwd, ["diff", "--quiet", `${baseRef}...${headRef}`], true);
+    return false;
+  } catch {
+    return true;
   }
-  assertTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
 }
-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();
-  });
+var FEATURE_BRANCH_RE = /^feat\/task-.+/;
+function isFeatureBranchName(branch) {
+  return FEATURE_BRANCH_RE.test(branch.trim().replace(/^origin\//, ""));
 }
-function assertWebIdeTemplateCopiedToApm(apmDir, workdir) {
-  const required = ["AGENTS.md", "apm.config.json", "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 hasUpstream(cwd) {
+  try {
+    await execGit(cwd, ["rev-parse", "--abbrev-ref", "@{upstream}"], true);
+    return true;
+  } catch {
+    return false;
   }
 }
-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}`);
+async function pushCurrentBranch(cwd) {
+  if (!await isGitRepo(cwd)) {
+    return false;
   }
-  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}`);
+  const originUrl = await tryReadGitOriginUrl(cwd);
+  if (!originUrl) {
+    console.log("[apm] \u672A\u914D\u7F6E remote.origin\uFF0C\u8DF3\u8FC7 push");
+    return false;
   }
-  mkdirSync2(toFsPath(resolvedTarget), { recursive: true });
-  copyFileSync(toFsPath(agentsSrc), toFsPath(join2(resolvedTarget, "AGENTS.md")));
-  copyTemplateEntry(
-    join2(templateDir, "apm.config.json"),
-    join2(resolvedTarget, "apm.config.json")
-  );
-  const rulesDest = join2(resolvedTarget, "rules");
-  mkdirSync2(toFsPath(rulesDest), { recursive: true });
-  for (const name of ruleNames) {
-    copyTemplateEntry(join2(rulesSrc, name), join2(rulesDest, name));
+  if (await hasUpstream(cwd)) {
+    await execGit(cwd, ["push"]);
+  } else {
+    await execGit(cwd, ["push", "-u", "origin", "HEAD"]);
   }
-  assertWebIdeTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
+  return true;
 }
 
 // src/workspace-repos.ts
@@ -802,7 +574,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"]);
@@ -1026,7 +798,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
@@ -1099,57 +871,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;
       }
     }
   }
@@ -1168,9 +930,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);
@@ -1500,132 +1260,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,
@@ -1689,25 +1323,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: {
@@ -1727,7 +1347,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) {
@@ -2147,11 +1767,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
@@ -2211,11 +1827,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(),
@@ -2229,19 +1840,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,
@@ -2258,29 +1856,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)) {
@@ -2291,7 +1882,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");
@@ -2302,54 +1893,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;
@@ -2361,14 +1934,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) {
@@ -2384,7 +1957,7 @@ async function runCursorAgent(cfg, ctx, options) {
           );
         }
       }
-      options?.onStreamEvent?.(event);
+      options.onStreamEvent?.(event);
       eventSession.addEvent(event);
       syncRemoteLog.schedule(eventSession);
     }
@@ -2461,17 +2034,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 = {};
@@ -2499,16 +2072,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,
@@ -2532,30 +2105,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"
@@ -2619,8 +2192,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 {
@@ -2742,14 +2315,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) {
@@ -2938,56 +2511,33 @@ function resolveMessageReplyFallback(fallback) {
 }
 
 // src/commands/init.ts
-import { join as join4 } from "path";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
-function applyWorkspaceName(apmDir, name) {
-  const trimmedName = name?.trim();
-  if (!trimmedName) return;
-  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"
-  );
-}
-async function initializeWorkspace(workdir, options) {
+async function initializeWorkspace(workdir) {
   await ensureWorkspaceApmDirForInit(workdir);
   const apmDir = workspaceApmDir(workdir);
-  if (options?.webide) {
-    await copyWebIdeTemplateFiles(apmDir, workdir);
-  } else {
-    await copyTemplateFiles(apmDir, workdir);
-  }
-  applyWorkspaceName(apmDir, options?.name);
-  console.log(
-    options?.webide ? `[apm] \u5DF2\u6309 WebIDE \u521D\u59CB\u5316\u5DE5\u4F5C\u533A\uFF1A${apmDir}` : `[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(
-    options?.webide ? `[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` : `[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
@@ -3085,7 +2635,7 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
     };
   }
   if (!projectBaseBranch) {
-    const tip = "\u9879\u76EE\u672A\u914D\u7F6E\u57FA\u7840\u5206\u652F\uFF0C\u65E0\u6CD5\u6309\u57FA\u7EBF\u5339\u914D\u5E73\u53F0\u4ED3\u5E93";
+    const tip = "\u9879\u76EE\u672A\u914D\u7F6E\u57FA\u7840\u5206\u652F\uFF0C\u65E0\u6CD5\u521B\u5EFA PR";
     console.warn(`[apm] WebIDE PR\uFF1A${tip}`);
     return {
       ...empty(),
@@ -3109,7 +2659,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;
@@ -3135,7 +2685,7 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
         continue;
       }
       const headBranch = current;
-      const originUrl = await tryReadGitOriginUrl(gitRoot);
+      const originUrl = await tryReadHttpsGitOriginUrl(gitRoot) ?? await tryReadGitOriginUrl(gitRoot);
       if (!originUrl) {
         const tip = `${label}\uFF1A\u65E0 remote.origin.url`;
         console.warn(`[apm] WebIDE PR\uFF1A\u8DF3\u8FC7 ${tip}`);
@@ -3149,29 +2699,7 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
         });
         continue;
       }
-      const matched = await api.cli.matchRepository({
-        url: originUrl,
-        baseBranch: projectBaseBranch
-      });
-      const repositoryId = matched.repositoryId?.trim();
-      if (!repositoryId) {
-        const tip = `${label}\uFF1A\u5E73\u53F0\u672A\u627E\u5230\u4ED3\u5E93\uFF08remote=${originUrl}\uFF0C\u57FA\u7EBF=${projectBaseBranch}\uFF09`;
-        console.warn(`[apm] WebIDE PR\uFF1A\u8DF3\u8FC7 ${tip}`);
-        tips.push(tip);
-        skipped += 1;
-        items.push({
-          label,
-          outcome: "skipped",
-          headBranch,
-          baseBranch: projectBaseBranch,
-          detail: tip
-        });
-        continue;
-      }
-      const baseBranch = await resolveFeatureBranchBaseFromGit(
-        gitRoot,
-        headBranch
-      );
+      const baseBranch = projectBaseBranch;
       const hasChanges = await branchHasChangesAgainstBase(
         gitRoot,
         baseBranch,
@@ -3193,7 +2721,7 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
       }
       const pr = await api.cli.createWebIdeDraftPullRequest({
         taskId,
-        repositoryId,
+        originUrl,
         headBranch,
         baseBranch
       });
@@ -3227,23 +2755,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/sync-session-attachments.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join6 } 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(/\/+$/, "");
@@ -3259,13 +2787,13 @@ async function downloadAttachment(cfg, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path = join6(dir, MANIFEST_FILE);
-  if (!existsSync6(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;
@@ -3275,15 +2803,15 @@ function loadManifest(dir) {
   return { version: 1, attachments: {} };
 }
 function saveManifest(dir, manifest) {
-  writeFileSync6(
-    join6(dir, MANIFEST_FILE),
+  writeFileSync4(
+    join5(dir, MANIFEST_FILE),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
 function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync6(dest)) return false;
+  if (!entry || !existsSync5(dest)) return false;
   if (entry.name !== item.name) return false;
   const createdAt = item.createdAt ?? "";
   return entry.createdAt === createdAt;
@@ -3298,7 +2826,7 @@ async function syncAttachmentsToDirectory(cfg, attachments, dir, logLabel) {
   const nextManifest = { version: 1, attachments: {} };
   const names = [];
   for (const item of attachments) {
-    const dest = join6(dir, item.name);
+    const dest = join5(dir, item.name);
     const entry = manifest.attachments[item.id];
     const createdAt = item.createdAt ?? "";
     names.push(item.name);
@@ -3308,7 +2836,7 @@ async function syncAttachmentsToDirectory(cfg, attachments, dir, logLabel) {
       continue;
     }
     const buffer = await downloadAttachment(cfg, item.id);
-    writeFileSync6(dest, buffer);
+    writeFileSync4(dest, buffer);
     nextManifest.attachments[item.id] = {
       name: item.name,
       createdAt
@@ -3330,14 +2858,14 @@ async function syncWebIdeAttachments(cfg, taskId, workdir, attachments) {
 
 // src/project-documents-sync.ts
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync6,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync5
 } from "fs";
 import { createHash } from "crypto";
-import { dirname as dirname6, join as join7, 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();
@@ -3351,11 +2879,11 @@ function normalizeProjectIdForPath(projectId) {
 }
 function projectDocumentsDir(apmRoot, projectId) {
   const id = normalizeProjectIdForPath(projectId);
-  return join7(apmRoot ?? workspaceApmDir(), "project", id);
+  return join6(apmRoot ?? workspaceApmDir(), "project", id);
 }
 function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
-  return join7(
+  return join6(
     projectDocumentsDir(apmRoot, projectId),
     ...normalized.split("/")
   );
@@ -3375,16 +2903,16 @@ function hashLocalFileContent(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 function readLocalManifest(apmRoot, projectId) {
-  const manifestPath3 = join7(
+  const manifestPath3 = join6(
     projectDocumentsDir(apmRoot, projectId),
     MANIFEST_FILE2
   );
-  if (!existsSync7(manifestPath3)) {
+  if (!existsSync6(manifestPath3)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync8(manifestPath3, "utf8")
+      readFileSync6(manifestPath3, "utf8")
     );
   } catch {
     return null;
@@ -3392,13 +2920,13 @@ function readLocalManifest(apmRoot, projectId) {
 }
 function listLocalDocumentPaths(apmRoot, projectId) {
   const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync7(root)) {
+  if (!existsSync6(root)) {
     return [];
   }
   const paths = [];
   const walk = (dir) => {
     for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const abs = join7(dir, entry.name);
+      const abs = join6(dir, entry.name);
       if (entry.isDirectory()) {
         walk(abs);
         continue;
@@ -3516,8 +3044,8 @@ ${diagnostic ?? ""}`);
       const absPath = toFsPath(
         projectDocumentLocalPath(targetApmDir, projectId, doc.path)
       );
-      await ensureDirExists(dirname6(absPath));
-      writeFileSync7(absPath, doc.content, "utf8");
+      await ensureDirExists(dirname5(absPath));
+      writeFileSync5(absPath, doc.content, "utf8");
       downloaded += 1;
     }
   }
@@ -3526,13 +3054,13 @@ ${diagnostic ?? ""}`);
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path)
     );
-    if (existsSync7(absPath)) {
+    if (existsSync6(absPath)) {
       rmSync2(absPath, { force: true });
       deleted += 1;
     }
   }
-  writeFileSync7(
-    toFsPath(join7(docsDir, MANIFEST_FILE2)),
+  writeFileSync5(
+    toFsPath(join6(docsDir, MANIFEST_FILE2)),
     `${JSON.stringify(remoteManifest, null, 2)}
 `,
     "utf8"
@@ -3575,7 +3103,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;
@@ -3596,20 +3124,20 @@ async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot, options) {
 }
 
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
-import { join as join8 } 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 join8(apmDir, CLI_VERSION_FILE);
+  return join7(apmDir, CLI_VERSION_FILE);
 }
 function loadManifest2(apmDir) {
   const path = toFsPath(manifestPath2(apmDir));
-  if (!existsSync8(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;
@@ -3620,7 +3148,7 @@ function loadManifest2(apmDir) {
 }
 function saveManifest2(apmDir, cliVersion) {
   const manifest = { version: 1, cliVersion };
-  writeFileSync8(
+  writeFileSync6(
     toFsPath(manifestPath2(apmDir)),
     `${JSON.stringify(manifest, null, 2)}
 `,
@@ -3680,7 +3208,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}`
   );
@@ -3726,9 +3254,7 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
     await runPrepStep(
       "\u521D\u59CB\u5316\u5DE5\u4F5C\u533A",
       async () => {
-        const { didInit } = await ensureWorkspaceInitialized(workdir, {
-          webide: true
-        });
+        const { didInit } = await ensureWorkspaceInitialized(workdir);
         return didInit;
       },
       (didInit) => didInit ? "\u5DF2\u521D\u59CB\u5316\u5DE5\u4F5C\u533A" : "\u5DE5\u4F5C\u533A\u5DF2\u5C31\u7EEA"
@@ -3872,7 +3398,6 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
       cfg,
       {
         messageId,
-        sessionId: `webide:${taskId}`,
         prompt: msg.content,
         model: msg.model,
         apiKey: msg.apiKey,
@@ -3892,7 +3417,6 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
         }),
         enableWebIdePlanTools: true,
         enableSandbox: false,
-        skipSessionAgentRegistry: true,
         onInvalidatePersistedAgentId: () => clearWebIdeAgentId(workdir, taskId),
         taskId,
         terminalRpc: options?.terminalRpc,
@@ -4103,12 +3627,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,