ai-project-manage-cli 8.1.20 → 8.1.22

package/dist/worker-script.js

@@ -115,38 +115,10 @@ var requestConfig = {
       method: "POST",
       path: "/cli/webide/pull-requests/merge"
     }),
-    getProjectDocumentManifest: defineEndpoint({
-      method: "GET",
-      path: "/cli/project-documents/manifest"
-    }),
-    listProjectDocuments: defineEndpoint({
-      method: "GET",
-      path: "/cli/project-documents"
-    }),
-    upsertProjectDocument: defineEndpoint({
-      method: "PUT",
-      path: "/cli/project-documents/upsert"
-    }),
-    removeProjectDocument: defineEndpoint({
-      method: "DELETE",
-      path: "/cli/project-documents"
-    }),
     getApmLogStorage: defineEndpoint({
       method: "GET",
       path: "/cli/apm-log-storage"
     }),
-    projectPackageUpdateStatus: defineEndpoint({
-      method: "PUT",
-      path: "/cli/project-packages/status"
-    }),
-    projectPackageAppendContent: defineEndpoint({
-      method: "PUT",
-      path: "/cli/project-packages/content"
-    }),
-    projectPackageEnsureContent: defineEndpoint({
-      method: "PUT",
-      path: "/cli/project-packages/ensure-content"
-    }),
     cursorStoreUpsertAgent: defineEndpoint({
       method: "PUT",
       path: "/cli/cursor-store/agents"
@@ -207,6 +179,15 @@ function resolveClientMachineId(cfg2) {
 function resolveApiKey(cfg2) {
   return (cfg2.apiKey ?? cfg2.token ?? "").trim();
 }
+function stripTrailingSlash(raw) {
+  return raw.trim().replace(/\/+$/, "");
+}
+function readConfigSocketServer(cfg2) {
+  const fromNew = typeof cfg2.socketServer === "string" ? cfg2.socketServer.trim().replace(/\/+$/, "") : "";
+  if (fromNew) return fromNew;
+  const fromLegacy = typeof cfg2.wsUrl === "string" ? cfg2.wsUrl.trim().replace(/\/+$/, "") : "";
+  return fromLegacy;
+}
 function tryReadApmConfig() {
   try {
     const raw = readFileSync(APM_CONFIG_PATH, "utf8");
@@ -222,10 +203,12 @@ function tryReadApmConfig() {
     if (!apiKey) return null;
     const cfg2 = v;
     const clientMachineId = resolveClientMachineId(cfg2);
+    const socketServer = readConfigSocketServer(cfg2);
     return {
       baseUrl: cfg2.baseUrl.trim().replace(/\/+$/, ""),
       apiKey,
-      ...clientMachineId ? { clientMachineId } : {}
+      ...clientMachineId ? { clientMachineId } : {},
+      ...socketServer ? { socketServer } : {}
     };
   } catch {
     return null;
@@ -248,10 +231,14 @@ async function ensureApmConfig() {
 async function writeApmConfig(cfg2) {
   const clientMachineId = resolveClientMachineId(cfg2);
   const apiKey = resolveApiKey(cfg2);
+  const socketServer = stripTrailingSlash(
+    cfg2.socketServer?.trim() || cfg2.wsUrl?.trim() || ""
+  );
   const normalized = {
     baseUrl: cfg2.baseUrl.trim().replace(/\/+$/, ""),
     apiKey,
-    ...clientMachineId ? { clientMachineId } : {}
+    ...clientMachineId ? { clientMachineId } : {},
+    ...socketServer ? { socketServer } : {}
   };
   mkdirSync(APM_CONFIG_DIR, { recursive: true });
   writeFileSync(APM_CONFIG_PATH, JSON.stringify(normalized, null, 2) + "\n", {
@@ -284,8 +271,8 @@ function toFsPath(inputPath) {
   }
   return `\\\\?\\${normalized}`;
 }
-function normalizeWorkdirPath(path3) {
-  let normalized = path3.trim().replace(/\\/g, "/").normalize("NFC");
+function normalizeWorkdirPath(path) {
+  let normalized = path.trim().replace(/\\/g, "/").normalize("NFC");
   if (normalized.startsWith("//?/")) {
     normalized = normalized.slice(4);
   }
@@ -372,84 +359,66 @@ async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
 }
 
 // src/utils/git.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-
-// src/utils/git-remote.ts
 import { execFile } from "child_process";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
-function toHttpsGitRemoteUrl(raw) {
-  let s = raw.trim();
-  if (!s) return null;
-  const sshScp = /^git@([^:]+):(.+)$/.exec(s);
-  if (sshScp) {
-    s = `https://${sshScp[1]}/${sshScp[2]}`;
-  } else {
-    const sshUri = /^ssh:\/\/(?:git@)?([^/]+)\/(.+)$/i.exec(s);
-    if (sshUri) {
-      s = `https://${sshUri[1]}/${sshUri[2]}`;
-    } else if (/^http:\/\//i.test(s)) {
-      s = `https://${s.slice("http://".length)}`;
-    } else if (!/^https:\/\//i.test(s)) {
-      const scpLike = /^([^/:]+):(.+)$/.exec(s);
-      if (scpLike && !scpLike[1].includes(".")) {
-        return null;
-      }
-      if (scpLike) {
-        s = `https://${scpLike[1]}/${scpLike[2]}`;
-      } else if (s.includes("/")) {
-        s = `https://${s}`;
-      } else {
-        return null;
-      }
-    }
+var GIT_NETWORK_TIMEOUT_MS = 9e4;
+var GIT_PUSH_TIMEOUT_MS = 12e4;
+var GIT_LOCAL_TIMEOUT_MS = 6e4;
+var GIT_NETWORK_CMDS = /* @__PURE__ */ new Set([
+  "fetch",
+  "push",
+  "ls-remote",
+  "clone",
+  "pull"
+]);
+function mergeGitSshCommand(existing) {
+  const base = existing?.trim() || "ssh";
+  const extras = [];
+  if (!/\bStrictHostKeyChecking=/.test(base)) {
+    extras.push("-o", "StrictHostKeyChecking=accept-new");
   }
-  s = s.replace(/\/+$/, "");
-  if (!/^https:\/\//i.test(s)) return null;
-  return s;
-}
-async function tryReadGitOriginUrl(cwd) {
-  try {
-    const { stdout } = await execFileAsync(
-      "git",
-      ["config", "--get", "remote.origin.url"],
-      { cwd, encoding: "utf8", maxBuffer: 1024 * 1024 }
-    );
-    const url = stdout.trim();
-    return url || null;
-  } catch {
-    return null;
+  if (!/\bBatchMode=/.test(base)) {
+    extras.push("-o", "BatchMode=yes");
   }
+  if (!/\bConnectTimeout=/.test(base)) {
+    extras.push("-o", "ConnectTimeout=20");
+  }
+  if (!/\bServerAliveInterval=/.test(base)) {
+    extras.push("-o", "ServerAliveInterval=10");
+  }
+  if (!/\bServerAliveCountMax=/.test(base)) {
+    extras.push("-o", "ServerAliveCountMax=3");
+  }
+  return extras.length ? `${base} ${extras.join(" ")}` : base;
 }
-async function tryReadHttpsGitOriginUrl(cwd) {
-  const raw = await tryReadGitOriginUrl(cwd);
-  if (!raw) return null;
-  return toHttpsGitRemoteUrl(raw);
-}
-
-// src/utils/git.ts
-var execFileAsync2 = promisify2(execFile2);
 function gitExecEnv() {
-  const existing = process.env.GIT_SSH_COMMAND?.trim();
-  const acceptNew = "-o StrictHostKeyChecking=accept-new";
-  let gitSshCommand;
-  if (!existing) {
-    gitSshCommand = `ssh ${acceptNew}`;
-  } else if (/\bStrictHostKeyChecking=/.test(existing)) {
-    gitSshCommand = existing;
-  } else {
-    gitSshCommand = `${existing} ${acceptNew}`;
-  }
-  return { ...process.env, GIT_SSH_COMMAND: gitSshCommand };
+  return {
+    ...process.env,
+    GIT_SSH_COMMAND: mergeGitSshCommand(process.env.GIT_SSH_COMMAND),
+    // 避免 credential helper / askpass 在无 TTY 时挂起
+    GIT_TERMINAL_PROMPT: "0"
+  };
+}
+function defaultGitTimeoutMs(args) {
+  const cmd = args[0] ?? "";
+  if (cmd === "push") return GIT_PUSH_TIMEOUT_MS;
+  if (GIT_NETWORK_CMDS.has(cmd)) return GIT_NETWORK_TIMEOUT_MS;
+  return GIT_LOCAL_TIMEOUT_MS;
 }
-async function execGit(cwd, args, quiet = false) {
+async function execGit(cwd, args, quietOrOptions = false) {
+  const options = typeof quietOrOptions === "boolean" ? { quiet: quietOrOptions } : quietOrOptions;
+  const quiet = options.quiet ?? false;
+  const timeoutMs = options.timeoutMs === void 0 ? defaultGitTimeoutMs(args) : options.timeoutMs;
   try {
-    const { stdout, stderr } = await execFileAsync2("git", args, {
+    const { stdout, stderr } = await execFileAsync("git", args, {
       cwd,
       env: gitExecEnv(),
       encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024
+      maxBuffer: 10 * 1024 * 1024,
+      ...timeoutMs > 0 ? { timeout: timeoutMs, killSignal: "SIGTERM" } : {}
     });
     if (!quiet && stderr.trim()) {
       process.stderr.write(stderr);
@@ -457,113 +426,224 @@ async function execGit(cwd, args, quiet = false) {
     return stdout;
   } catch (err) {
     const e = err;
+    if (e.killed || e.signal === "SIGTERM" || e.code === "ETIMEDOUT") {
+      throw new Error(
+        `[apm] git ${args.join(" ")} \u8D85\u65F6\uFF08>${timeoutMs}ms\uFF09\uFF0C\u8BF7\u68C0\u67E5\u5230\u8FDC\u7A0B\u7684\u7F51\u7EDC/SSH\uFF1B\u53EF\u7A0D\u540E\u91CD\u8BD5`
+      );
+    }
     const detail = (e.stderr ?? e.message ?? String(err)).trim();
     throw new Error(
       `[apm] git ${args.join(" ")} \u5931\u8D25${detail ? `: ${detail}` : ""}`
     );
   }
 }
-async function isGitRepo(cwd) {
-  try {
-    await execGit(cwd, ["rev-parse", "--git-dir"], true);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function ensureGitRepo(cwd) {
   await execGit(cwd, ["rev-parse", "--git-dir"], true);
 }
 async function getCurrentBranch(cwd) {
   return (await execGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], true)).trim();
 }
-async function isWorkingTreeDirty(cwd) {
-  const out = await execGit(cwd, ["status", "--porcelain"], true);
-  return out.trim().length > 0;
-}
-async function remoteBranchExists(cwd, branch) {
-  const out = await execGit(
-    cwd,
-    ["ls-remote", "--heads", "origin", branch],
-    true
-  );
-  return out.trim().length > 0;
-}
 async function resolveGitRepoRoot(cwd) {
   return (await execGit(cwd, ["rev-parse", "--show-toplevel"], true)).trim();
 }
-async function ensureRemoteBaselineBranch(cwd, baselineBranch) {
-  await execGit(cwd, ["fetch", "origin", baselineBranch], true);
-  if (await remoteBranchExists(cwd, baselineBranch)) {
-    return;
-  }
-  throw new Error(
-    `[apm] \u8FDC\u7A0B\u4E0D\u5B58\u5728\u57FA\u7EBF\u5206\u652F origin/${baselineBranch}\uFF0C\u8BF7\u786E\u8BA4\u4ED3\u5E93\u9ED8\u8BA4\u5206\u652F\u5DF2\u63A8\u9001\u5230 origin`
-  );
+var FEATURE_BRANCH_RE = /^feat\/task-(.+)$/;
+function isFeatureBranchName(branch) {
+  return FEATURE_BRANCH_RE.test(branch.trim().replace(/^origin\//, ""));
 }
-async function branchHasChangesAgainstBase(cwd, baseBranch, headBranch) {
-  const base = baseBranch.trim().replace(/^origin\//, "");
-  const head = headBranch.trim().replace(/^origin\//, "");
-  if (!base || !head) return false;
-  await execGit(cwd, ["fetch", "origin", base], true);
-  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;
-  }
+function resolveGitScript(name) {
+  return join3(dirname(fileURLToPath(import.meta.url)), "scripts", name);
+}
+async function runGitScript(name, options) {
+  const skipCode = options.skipCode ?? 2;
+  const timeoutMs = options.timeoutMs ?? GIT_NETWORK_TIMEOUT_MS;
+  const script = resolveGitScript(name);
+  const args = [script, ...options.args ?? []];
   try {
-    await execGit(cwd, ["diff", "--quiet", `${baseRef}...${headRef}`], true);
-    return false;
-  } catch {
+    const { stdout, stderr } = await execFileAsync("bash", args, {
+      cwd: options.cwd,
+      env: gitExecEnv(),
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: timeoutMs,
+      killSignal: "SIGTERM"
+    });
+    if (stdout.trim()) process.stdout.write(stdout);
+    if (stderr.trim()) process.stderr.write(stderr);
     return true;
+  } catch (err) {
+    const e = err;
+    if (e.stdout?.trim()) process.stdout.write(e.stdout);
+    if (e.stderr?.trim()) process.stderr.write(e.stderr);
+    if (e.code === skipCode) {
+      return false;
+    }
+    if (e.killed || e.signal === "SIGTERM" || e.code === "ETIMEDOUT") {
+      throw new Error(
+        `[apm] ${name} \u8D85\u65F6\uFF08>${timeoutMs}ms\uFF09\uFF0C\u8BF7\u68C0\u67E5\u5230\u8FDC\u7A0B\u7684\u7F51\u7EDC/SSH\uFF1B\u53EF\u7A0D\u540E\u91CD\u8BD5`
+      );
+    }
+    const detail = (e.stderr ?? e.message ?? String(err)).trim();
+    throw new Error(`[apm] ${name} \u5931\u8D25${detail ? `: ${detail}` : ""}`);
   }
 }
-var FEATURE_BRANCH_RE = /^feat\/task-(.+)$/;
-function isFeatureBranchName(branch) {
-  return FEATURE_BRANCH_RE.test(branch.trim().replace(/^origin\//, ""));
+async function branchHasChangesAgainstBase(cwd, baseBranch, headBranch) {
+  return runGitScript("branch_has_changes.sh", {
+    cwd,
+    args: [baseBranch, headBranch],
+    timeoutMs: GIT_NETWORK_TIMEOUT_MS
+  });
+}
+async function commitWorkingTreeIfDirty(cwd, message) {
+  await ensureGitRepo(cwd);
+  return runGitScript("commit_if_dirty.sh", {
+    cwd,
+    args: message?.trim() ? [message.trim()] : [],
+    timeoutMs: GIT_LOCAL_TIMEOUT_MS
+  });
 }
-function taskIdFromFeatureBranch(branch) {
-  const name = branch.trim().replace(/^origin\//, "");
-  const match = name.match(FEATURE_BRANCH_RE);
-  const id = match?.[1]?.trim() ?? "";
-  return id || null;
+async function ensureFeatureBranch(cwd, branch, baselineBranch) {
+  await runGitScript("ensure_feature_branch.sh", {
+    cwd,
+    args: [branch, baselineBranch],
+    timeoutMs: GIT_PUSH_TIMEOUT_MS
+  });
 }
 async function pushCurrentBranch(cwd) {
-  if (!await isGitRepo(cwd)) {
-    return false;
+  return runGitScript("push_code.sh", {
+    cwd,
+    timeoutMs: GIT_PUSH_TIMEOUT_MS
+  });
+}
+
+// src/utils/home-repository.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join4, resolve as resolve3 } from "path";
+var HOME_REPOSITORY_JSON = "/home/repository.json";
+function isSimpleChildDirName(name) {
+  if (!name || name === "." || name === "..") return false;
+  if (name.includes("/") || name.includes("\\")) return false;
+  return true;
+}
+function loadHomeRepositoryEntries() {
+  const path = toFsPath(HOME_REPOSITORY_JSON);
+  if (!existsSync2(path)) {
+    throw new Error(`[apm] \u672A\u627E\u5230\u591A\u4ED3\u6E05\u5355 ${HOME_REPOSITORY_JSON}`);
   }
-  const originUrl = await tryReadGitOriginUrl(cwd);
-  if (!originUrl) {
-    console.log("[apm] \u672A\u914D\u7F6E remote.origin\uFF0C\u8DF3\u8FC7 push");
-    return false;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`[apm] \u89E3\u6790 ${HOME_REPOSITORY_JSON} \u5931\u8D25: ${detail}`);
   }
-  await execGit(cwd, ["push", "-u", "origin", "HEAD"]);
-  return true;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(
+      `[apm] ${HOME_REPOSITORY_JSON} \u987B\u4E3A\u5BF9\u8C61\uFF1Akey=\u4E0B\u7EA7\u76EE\u5F55\uFF0Cvalue=git \u5730\u5740`
+    );
+  }
+  const entries = [];
+  for (const [rawKey, rawVal] of Object.entries(
+    parsed
+  )) {
+    const pathKey = rawKey.trim();
+    if (!isSimpleChildDirName(pathKey)) {
+      throw new Error(
+        `[apm] ${HOME_REPOSITORY_JSON} \u975E\u6CD5\u76EE\u5F55 key: ${JSON.stringify(rawKey)}\uFF08\u987B\u4E3A\u5F53\u524D\u4E0B\u7EA7\u76EE\u5F55\u540D\uFF09`
+      );
+    }
+    if (typeof rawVal !== "string" || !rawVal.trim()) {
+      throw new Error(
+        `[apm] ${HOME_REPOSITORY_JSON}[${pathKey}] \u987B\u4E3A\u975E\u7A7A git \u5730\u5740\u5B57\u7B26\u4E32`
+      );
+    }
+    entries.push({ path: pathKey, remoteUrl: rawVal.trim() });
+  }
+  entries.sort((a, b) => a.path.localeCompare(b.path));
+  if (entries.length === 0) {
+    throw new Error(`[apm] ${HOME_REPOSITORY_JSON} \u4E3A\u7A7A\uFF0C\u65E0\u4ED3\u5E93\u53EF\u786E\u8BA4`);
+  }
+  return entries;
+}
+function resolveHomeRepositoryAbsolutePaths(workdirInput, entries = loadHomeRepositoryEntries()) {
+  const workdir = resolveWorkdirPath(workdirInput);
+  return entries.map((entry) => resolve3(join4(workdir, entry.path)));
+}
+function tryLoadHomeRepositoryEntries() {
+  const path = toFsPath(HOME_REPOSITORY_JSON);
+  if (!existsSync2(path)) return null;
+  return loadHomeRepositoryEntries();
 }
 
 // src/utils/workspace-repos.ts
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   readdirSync as readdirSync2,
   statSync as statSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename, dirname, join as join3, relative, resolve as resolve3 } from "path";
+import { basename, dirname as dirname2, join as join5, relative, resolve as resolve4 } from "path";
+
+// src/utils/git-remote.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+function toHttpsGitRemoteUrl(raw) {
+  let s = raw.trim();
+  if (!s) return null;
+  const sshScp = /^git@([^:]+):(.+)$/.exec(s);
+  if (sshScp) {
+    s = `https://${sshScp[1]}/${sshScp[2]}`;
+  } else {
+    const sshUri = /^ssh:\/\/(?:git@)?([^/]+)\/(.+)$/i.exec(s);
+    if (sshUri) {
+      s = `https://${sshUri[1]}/${sshUri[2]}`;
+    } else if (/^http:\/\//i.test(s)) {
+      s = `https://${s.slice("http://".length)}`;
+    } else if (!/^https:\/\//i.test(s)) {
+      const scpLike = /^([^/:]+):(.+)$/.exec(s);
+      if (scpLike && !scpLike[1].includes(".")) {
+        return null;
+      }
+      if (scpLike) {
+        s = `https://${scpLike[1]}/${scpLike[2]}`;
+      } else if (s.includes("/")) {
+        s = `https://${s}`;
+      } else {
+        return null;
+      }
+    }
+  }
+  s = s.replace(/\/+$/, "");
+  if (!/^https:\/\//i.test(s)) return null;
+  return s;
+}
+async function tryReadGitOriginUrl(cwd) {
+  try {
+    const { stdout } = await execFileAsync2(
+      "git",
+      ["config", "--get", "remote.origin.url"],
+      { cwd, encoding: "utf8", maxBuffer: 1024 * 1024 }
+    );
+    const url = stdout.trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+async function tryReadHttpsGitOriginUrl(cwd) {
+  const raw = await tryReadGitOriginUrl(cwd);
+  if (!raw) return null;
+  return toHttpsGitRemoteUrl(raw);
+}
+
+// src/utils/workspace-repos.ts
 var WORKSPACE_REPOS_MANIFEST = "workspace-repos.json";
 var WORKSPACE_REPOS_VERSION = 1;
 var SKIP_DIR_NAMES = /* @__PURE__ */ new Set([".apm", "node_modules"]);
 function hasGitAt(dir) {
-  return existsSync2(toFsPath(join3(dir, ".git")));
+  return existsSync3(toFsPath(join5(dir, ".git")));
 }
 function isSkippableChildName(name) {
   if (SKIP_DIR_NAMES.has(name)) return true;
@@ -571,25 +651,21 @@ function isSkippableChildName(name) {
   return false;
 }
 function manifestPath(workdir) {
-  return join3(workspaceApmDir(workdir), WORKSPACE_REPOS_MANIFEST);
+  return join5(workspaceApmDir(workdir), WORKSPACE_REPOS_MANIFEST);
 }
 function absoluteRepoPath(workdir, entry) {
-  if (entry.path === "." || entry.path === "") {
-    return workdir;
-  }
-  return resolve3(workdir, entry.path);
+  return resolve4(workdir, entry.path);
 }
 function toRelativeRepoPath(workdir, repoAbs) {
-  const rel = relative(workdir, repoAbs).replace(/\\/g, "/");
-  return rel === "" ? "." : rel;
+  return relative(workdir, repoAbs).replace(/\\/g, "/");
 }
 function normalizeRepoEntry(raw) {
   if (!raw || typeof raw !== "object") return null;
   const o = raw;
   if (typeof o.path !== "string" || !o.path.trim()) return null;
-  const entry = {
-    path: o.path.trim().replace(/\\/g, "/")
-  };
+  const path = o.path.trim().replace(/\\/g, "/");
+  if (path === "." || path.includes("/")) return null;
+  const entry = { path };
   if (typeof o.remoteUrl === "string" && o.remoteUrl.trim()) {
     entry.remoteUrl = o.remoteUrl.trim();
   } else if (o.remoteUrl === null) {
@@ -598,18 +674,18 @@ function normalizeRepoEntry(raw) {
   return entry;
 }
 function readManifest(workdir) {
-  const path3 = toFsPath(manifestPath(workdir));
-  if (!existsSync2(path3)) {
+  const path = toFsPath(manifestPath(workdir));
+  if (!existsSync3(path)) {
     return null;
   }
   try {
     const raw = JSON.parse(
-      readFileSync2(path3, "utf8")
+      readFileSync3(path, "utf8")
     );
     if (raw?.version !== WORKSPACE_REPOS_VERSION) {
       return null;
     }
-    if (raw.kind !== "single" && raw.kind !== "multi") {
+    if (raw.kind !== "multi") {
       return null;
     }
     if (!Array.isArray(raw.repos) || raw.repos.length === 0) {
@@ -624,7 +700,7 @@ function readManifest(workdir) {
     }
     return {
       version: WORKSPACE_REPOS_VERSION,
-      kind: raw.kind,
+      kind: "multi",
       workdir: raw.workdir,
       repos,
       scannedAt: typeof raw.scannedAt === "string" && raw.scannedAt.trim() ? raw.scannedAt : (/* @__PURE__ */ new Date()).toISOString()
@@ -636,8 +712,8 @@ function readManifest(workdir) {
 function writeManifest(workdir, manifest) {
   const apmDir = toFsPath(workspaceApmDir(workdir));
   mkdirSync3(apmDir, { recursive: true });
-  const path3 = toFsPath(manifestPath(workdir));
-  writeFileSync2(path3, `${JSON.stringify(manifest, null, 2)}
+  const path = toFsPath(manifestPath(workdir));
+  writeFileSync2(path, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 function manifestStillValid(workdir, manifest) {
@@ -648,6 +724,9 @@ function manifestStillValid(workdir, manifest) {
     if (typeof entry?.path !== "string" || !entry.path.trim()) {
       return false;
     }
+    if (entry.path === "." || entry.path.includes("/")) {
+      return false;
+    }
     const abs = absoluteRepoPath(workdir, entry);
     if (!hasGitAt(abs)) {
       return false;
@@ -657,17 +736,8 @@ function manifestStillValid(workdir, manifest) {
 }
 function scanWorkspaceRepos(workdirInput) {
   const workdir = resolveWorkdirPath(workdirInput);
-  if (hasGitAt(workdir)) {
-    return {
-      version: WORKSPACE_REPOS_VERSION,
-      kind: "single",
-      workdir,
-      repos: [{ path: "." }],
-      scannedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
   const fsWorkdir = toFsPath(workdir);
-  if (!existsSync2(fsWorkdir) || !statSync2(fsWorkdir).isDirectory()) {
+  if (!existsSync3(fsWorkdir) || !statSync2(fsWorkdir).isDirectory()) {
     throw new Error(`[apm] \u5DE5\u4F5C\u533A\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55: ${workdir}`);
   }
   const repos = [];
@@ -675,9 +745,9 @@ function scanWorkspaceRepos(workdirInput) {
     if (isSkippableChildName(name)) {
       continue;
     }
-    const childAbs = resolve3(workdir, name);
+    const childAbs = resolve4(workdir, name);
     const childFs = toFsPath(childAbs);
-    if (!existsSync2(childFs) || !statSync2(childFs).isDirectory()) {
+    if (!existsSync3(childFs) || !statSync2(childFs).isDirectory()) {
       continue;
     }
     if (!hasGitAt(childAbs)) {
@@ -688,7 +758,7 @@ function scanWorkspaceRepos(workdirInput) {
   repos.sort((a, b) => a.path.localeCompare(b.path));
   if (repos.length === 0) {
     throw new Error(
-      `[apm] \u5DE5\u4F5C\u533A ${workdir} \u6839\u76EE\u5F55\u65E0 .git\uFF0C\u4E14\u4E00\u7EA7\u5B50\u76EE\u5F55\u4E2D\u672A\u53D1\u73B0 git \u4ED3\u5E93`
+      `[apm] \u5DE5\u4F5C\u533A ${workdir} \u4E00\u7EA7\u5B50\u76EE\u5F55\u4E2D\u672A\u53D1\u73B0 git \u4ED3\u5E93`
     );
   }
   return {
@@ -716,7 +786,7 @@ function loadWorkspaceReposCache(workdirInput) {
     throw new Error(`[apm] \u5DE5\u4F5C\u533A\u4ED3\u5E93\u7F13\u5B58\u65E0\u6548\uFF08repos \u4E3A\u7A7A\uFF09\uFF0C\u8BF7\u5F3A\u5236\u91CD\u65B0\u626B\u63CF`);
   }
   console.log(
-    `[apm] \u8BFB\u53D6\u5DE5\u4F5C\u533A\u4ED3\u5E93\u7F13\u5B58 kind=${cached.kind} repos=${cached.repos.map((r) => r.path).join(", ")}`
+    `[apm] \u8BFB\u53D6\u5DE5\u4F5C\u533A\u4ED3\u5E93\u7F13\u5B58 repos=${cached.repos.map((r) => r.path).join(", ")}`
   );
   return {
     ...cached,
@@ -754,7 +824,7 @@ function resolveWorkspaceRepos(workdirInput, options) {
     const cached = readManifest(workdir);
     if (cached && manifestStillValid(workdir, cached)) {
       console.log(
-        `[apm] \u4F7F\u7528\u7F13\u5B58\u7684\u5DE5\u4F5C\u533A\u4ED3\u5E93\u6E05\u5355 kind=${cached.kind} repos=${cached.repos.length}`
+        `[apm] \u4F7F\u7528\u7F13\u5B58\u7684\u5DE5\u4F5C\u533A\u4ED3\u5E93\u6E05\u5355 repos=${cached.repos.length}`
       );
       return cached;
     }
@@ -771,7 +841,7 @@ function resolveWorkspaceRepos(workdirInput, options) {
   }
   writeManifest(workdir, scanned);
   console.log(
-    `[apm] \u5DF2\u626B\u63CF\u5DE5\u4F5C\u533A\u4ED3\u5E93 kind=${scanned.kind} repos=${scanned.repos.map((r) => r.path).join(", ")} \u2192 .apm/${WORKSPACE_REPOS_MANIFEST}`
+    `[apm] \u5DF2\u626B\u63CF\u5DE5\u4F5C\u533A\u4ED3\u5E93 repos=${scanned.repos.map((r) => r.path).join(", ")} \u2192 .apm/${WORKSPACE_REPOS_MANIFEST}`
   );
   return scanned;
 }
@@ -782,48 +852,64 @@ function resolveWorkspaceRepoAbsolutePaths(manifest) {
 }
 function formatRepoLabel(workdir, repoAbs) {
   const rel = toRelativeRepoPath(resolveWorkdirPath(workdir), repoAbs);
-  return rel === "." ? basename(repoAbs) || repoAbs : rel;
+  return rel || basename(repoAbs) || repoAbs;
 }
 
 // src/commands/branch.ts
 var TASK_BRANCH_PREFIX = "feat/task-";
-async function localBranchExists(cwd, branch) {
-  try {
-    await execGit(
-      cwd,
-      ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
-      true
-    );
-    return true;
-  } catch {
-    return false;
-  }
+async function commitWorkspaceReposIfDirty(workdir, message) {
+  const result = await commitTaskReposIfDirty(workdir, message);
+  return result.committed;
 }
-async function commitWorkingTreeIfDirty(cwd, message) {
-  await ensureGitRepo(cwd);
-  if (!await isWorkingTreeDirty(cwd)) {
-    return false;
-  }
-  const commitMessage = message?.trim() || `chore(apm): \u540C\u6B65\u5DE5\u4F5C\u533A (${await getCurrentBranch(cwd)})`;
-  await execGit(cwd, ["add", "-A"]);
-  await execGit(cwd, ["commit", "-m", commitMessage]);
-  console.log(`[apm] \u5DF2\u63D0\u4EA4\u5DE5\u4F5C\u533A\u53D8\u66F4: ${commitMessage}`);
-  return true;
+async function commitTaskReposIfDirty(workdir, message) {
+  return syncTaskRepos(workdir, message);
 }
-async function commitWorkspaceReposIfDirty(workdir, message) {
+async function syncTaskRepos(workdir, message) {
   const workdirPath = resolveWorkdirPath(workdir);
-  const manifest = loadWorkspaceReposCache(workdirPath);
-  const repoRoots = resolveWorkspaceRepoAbsolutePaths(manifest);
+  const repoRoots = resolveTaskBranchRepoRoots(workdirPath);
   let committed = 0;
+  let commitSkipped = 0;
+  let pushed = 0;
+  let pushSkipped = 0;
+  const failed = [];
   for (const gitRoot of repoRoots) {
     const label = formatRepoLabel(workdirPath, gitRoot);
-    const did = await commitWorkingTreeIfDirty(gitRoot, message);
-    if (did) {
-      committed += 1;
-      console.log(`[apm] WebIDE \u515C\u5E95\u63D0\u4EA4 @ ${label}`);
+    try {
+      const didCommit = await commitWorkingTreeIfDirty(gitRoot, message);
+      if (didCommit) {
+        committed += 1;
+        console.log(`[apm] \u5DF2\u63D0\u4EA4 @ ${label}`);
+      } else {
+        commitSkipped += 1;
+      }
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      console.error(`[apm] \u4ED3\u5E93 ${label} \u63D0\u4EA4\u5931\u8D25\uFF08\u7EE7\u7EED\u5176\u5B83\u4ED3\uFF09: ${detail}`);
+      failed.push(label);
+      continue;
+    }
+    try {
+      const didPush = await pushCurrentBranch(gitRoot);
+      if (didPush) {
+        pushed += 1;
+        console.log(`[apm] \u5DF2 push @ ${label}`);
+      } else {
+        pushSkipped += 1;
+      }
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      console.error(`[apm] \u4ED3\u5E93 ${label} push \u5931\u8D25\uFF08\u7EE7\u7EED\u5176\u5B83\u4ED3\uFF09: ${detail}`);
+      failed.push(label);
     }
   }
-  return committed;
+  return {
+    committed,
+    commitSkipped,
+    pushed,
+    pushSkipped,
+    failed,
+    repos: repoRoots
+  };
 }
 async function pushWorkspaceRepos(workdir) {
   const workdirPath = resolveWorkdirPath(workdir);
@@ -852,58 +938,13 @@ function branchNameForTask(taskId) {
   }
   return `${TASK_BRANCH_PREFIX}${id}`;
 }
-async function ensureFeatureBranch(branch, baselineBranch, options) {
+async function ensureTaskFeatureBranch(branch, projectId, options) {
   const cwd = options.cwd ?? process.cwd();
   const gitRoot = await resolveGitRepoRoot(cwd);
-  await ensureGitRepo(gitRoot);
-  const current = await getCurrentBranch(gitRoot);
-  if (current === branch) {
-    console.log(`[apm] \u5DF2\u5728\u5206\u652F ${branch}\uFF0C\u8DF3\u8FC7`);
-    return branch;
-  }
-  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 {
-    await execGit(gitRoot, ["fetch", "origin", baselineBranch]);
-    try {
-      await execGit(gitRoot, [
-        "checkout",
-        "--no-track",
-        "-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;
-      }
-    }
-  }
-  console.log(`[apm] \u5DF2\u5C31\u7EEA\u5206\u652F ${branch}`);
+  await ensureFeatureBranch(gitRoot, branch, projectId);
   return branch;
 }
-async function runTaskBranch(taskId, options = {}) {
+async function resolveProjectIdForTask(taskId) {
   const trimmedTaskId = taskId.trim();
   if (!trimmedTaskId) {
     throw new Error("[apm] taskId \u4E0D\u80FD\u4E3A\u7A7A");
@@ -913,75 +954,73 @@ async function runTaskBranch(taskId, options = {}) {
   const projectBaseline = await api.cli.projectBaseBranch({
     taskId: trimmedTaskId
   });
-  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");
+  const projectId = projectBaseline.baseBranch?.trim() ?? "";
+  if (!projectId) {
+    throw new Error("[apm] \u9879\u76EE\u672A\u914D\u7F6E\u57FA\u7840\u5206\u652F / \u9879\u76EE ID\uFF0C\u65E0\u6CD5\u521B\u5EFA WebIDE \u7279\u6027\u5206\u652F");
   }
-  const cwd = options.cwd ?? process.cwd();
-  const workdirPath = resolveWorkdirPath(cwd);
-  const manifest = loadWorkspaceReposCache(workdirPath);
-  const repoRoots = resolveWorkspaceRepoAbsolutePaths(manifest);
-  const branch = branchNameForTask(trimmedTaskId);
-  for (const gitRoot of repoRoots) {
-    const label = formatRepoLabel(workdirPath, gitRoot);
+  return projectId;
+}
+function resolveTaskBranchRepoRoots(workdirPath) {
+  const entries = tryLoadHomeRepositoryEntries();
+  if (entries) {
+    const roots = resolveHomeRepositoryAbsolutePaths(workdirPath, entries);
     console.log(
-      `[apm] \u4EFB\u52A1\u5206\u652F ${branch} @ ${label} (project baseline=${baselineBranch})`
+      `[apm] \u8BFB\u53D6 ${HOME_REPOSITORY_JSON} repos=${entries.map((e) => `${e.path}\u2192${e.remoteUrl}`).join(", ")}`
     );
-    await ensureFeatureBranch(branch, baselineBranch, {
-      ...options,
-      cwd: gitRoot
-    });
+    return roots;
   }
-  return {
-    branch,
-    baseline: baselineBranch,
-    kind: manifest.kind,
-    repos: repoRoots
-  };
+  const manifest = loadWorkspaceReposCache(workdirPath);
+  return resolveWorkspaceRepoAbsolutePaths(manifest);
 }
-async function checkoutBaselineBranches(baselineBranch, options = {}) {
-  const baseline = baselineBranch.trim().replace(/^origin\//, "");
-  if (!baseline) {
-    throw new Error("[apm] \u57FA\u7EBF\u5206\u652F\u4E0D\u80FD\u4E3A\u7A7A");
+async function runTaskBranch(taskId, projectId, options = {}) {
+  const trimmedTaskId = taskId.trim();
+  if (!trimmedTaskId) {
+    throw new Error("[apm] taskId \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const trimmedProjectId = projectId.trim();
+  if (!trimmedProjectId) {
+    throw new Error("[apm] projectId\uFF08\u9879\u76EE ID\uFF09\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (/[\s\\]/.test(trimmedProjectId) || trimmedProjectId.includes("..")) {
+    throw new Error("[apm] \u9879\u76EE ID \u975E\u6CD5");
   }
   const cwd = options.cwd ?? process.cwd();
   const workdirPath = resolveWorkdirPath(cwd);
-  const manifest = loadWorkspaceReposCache(workdirPath);
-  const repoRoots = resolveWorkspaceRepoAbsolutePaths(manifest);
+  const repoRoots = resolveTaskBranchRepoRoots(workdirPath);
+  if (repoRoots.length === 0) {
+    throw new Error("[apm] \u5DE5\u4F5C\u533A\u4ED3\u5E93\u6E05\u5355\u4E3A\u7A7A\uFF0C\u65E0\u6CD5\u786E\u8BA4\u7279\u6027\u5206\u652F");
+  }
+  const branch = branchNameForTask(trimmedTaskId);
+  const repoLabels = repoRoots.map(
+    (gitRoot) => formatRepoLabel(workdirPath, gitRoot)
+  );
+  console.log(
+    `[apm] \u591A\u4ED3\u786E\u8BA4\u7279\u6027\u5206\u652F ${branch} projectId=${trimmedProjectId} repos=${repoLabels.join(",")}`
+  );
   for (const gitRoot of repoRoots) {
     const label = formatRepoLabel(workdirPath, gitRoot);
-    console.log(`[apm] \u5207\u6362\u57FA\u7EBF\u5206\u652F ${baseline} @ ${label}`);
-    await checkoutBaselineBranch(baseline, { ...options, cwd: gitRoot });
+    console.log(
+      `[apm] \u4EFB\u52A1\u5206\u652F ${branch} @ ${label} (projectId=${trimmedProjectId})`
+    );
+    try {
+      await ensureTaskFeatureBranch(branch, trimmedProjectId, {
+        ...options,
+        cwd: gitRoot
+      });
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `[apm] \u4ED3\u5E93 ${label} \u786E\u8BA4\u7279\u6027\u5206\u652F\u5931\u8D25\uFF08\u591A\u4ED3\u4EFB\u4E00\u5931\u8D25\u5219\u6574\u6B21\u5931\u8D25\uFF09: ${detail}`
+      );
+    }
   }
   return {
-    baseline,
-    kind: manifest.kind,
+    branch,
+    projectId: trimmedProjectId,
+    kind: "multi",
     repos: repoRoots
   };
 }
-async function checkoutBaselineBranch(baselineBranch, options = {}) {
-  const baseline = baselineBranch.trim().replace(/^origin\//, "");
-  if (!baseline) {
-    throw new Error("[apm] \u57FA\u7EBF\u5206\u652F\u4E0D\u80FD\u4E3A\u7A7A");
-  }
-  const cwd = options.cwd ?? process.cwd();
-  const gitRoot = await resolveGitRepoRoot(cwd);
-  await ensureGitRepo(gitRoot);
-  if (await isWorkingTreeDirty(gitRoot)) {
-    throw new Error(`[apm] \u5DE5\u4F5C\u533A\u6709\u672A\u63D0\u4EA4\u53D8\u66F4\uFF0C\u65E0\u6CD5\u5207\u6362\u5230\u57FA\u7EBF\u5206\u652F ${baseline}`);
-  }
-  await ensureRemoteBaselineBranch(gitRoot, baseline);
-  const current = await getCurrentBranch(gitRoot);
-  if (current !== baseline) {
-    await execGit(gitRoot, ["checkout", "-B", baseline, `origin/${baseline}`]);
-  }
-  await execGit(gitRoot, ["reset", "--hard", `origin/${baseline}`]);
-  const head = (await execGit(gitRoot, ["rev-parse", "--short", "HEAD"], true)).trim();
-  console.log(
-    `[apm] \u5DF2\u5207\u6362\u5230\u57FA\u7EBF ${baseline}\uFF0C\u5E76\u5BF9\u9F50 origin/${baseline}\uFF08${head}\uFF09`
-  );
-  return baseline;
-}
 
 // src/commands/connect/cursor-agent.ts
 import {
@@ -1631,8 +1670,8 @@ function createUpsertWebIdeTestCasesTool(options) {
 }
 
 // src/commands/connect/tools/mysql-tools.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
-import { isAbsolute, relative as relative2, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
+import { isAbsolute, relative as relative2, resolve as resolve5 } from "node:path";
 import mysql from "mysql2/promise";
 var MAX_RESULT_ROWS = 100;
 var EXEC_TIMEOUT_MS = 6e4;
@@ -1703,14 +1742,14 @@ function resolveSqlArtifactPath(workdir, absolutePath) {
   if (!isAbsolute(absolutePath)) {
     return { ok: false, error: "path \u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84" };
   }
-  const workdirAbs = resolve4(toFsPath(workdir));
-  const targetAbs = resolve4(toFsPath(absolutePath));
+  const workdirAbs = resolve5(toFsPath(workdir));
+  const targetAbs = resolve5(toFsPath(absolutePath));
   const rel = relative2(workdirAbs, targetAbs);
   if (!rel || rel.startsWith("..") || isAbsolute(rel)) {
     return { ok: false, error: "path \u5FC5\u987B\u4F4D\u4E8E\u5F53\u524D\u5DE5\u4F5C\u533A\u5185" };
   }
   const fsPath = toFsPath(targetAbs);
-  if (!existsSync3(fsPath)) {
+  if (!existsSync4(fsPath)) {
     return { ok: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${absolutePath}` };
   }
   let st;
@@ -1732,7 +1771,7 @@ function resolveSqlArtifactPath(workdir, absolutePath) {
   return { ok: true, absPath: targetAbs, displayPath };
 }
 function readSqlFile(absPath) {
-  return readFileSync3(toFsPath(absPath), "utf8");
+  return readFileSync4(toFsPath(absPath), "utf8");
 }
 function createMysqlExecuteTool(options) {
   const { taskId, executionId, workdir, upsertSqlExecution } = options;
@@ -1910,2373 +1949,1213 @@ function createMysqlExecuteTool(options) {
   };
 }
 
-// src/commands/connect/tools/package-sql-tool.ts
-import { existsSync as existsSync4, statSync as statSync4 } from "node:fs";
-import { isAbsolute as isAbsolute2, relative as relative3, resolve as resolve5 } from "node:path";
-
-// src/commands/connect/sync-package-sql.ts
-import { createHash } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-
-// src/utils/minio.ts
-import * as Minio from "minio";
-var MinioClient = class {
-  inner;
-  constructor(opts) {
-    const endPoint = opts.endPoint.replace(/^https?:\/\//i, "").split("/")[0] ?? opts.endPoint;
-    this.inner = new Minio.Client({
-      endPoint,
-      port: opts.port,
-      useSSL: opts.useSSL,
-      accessKey: opts.accessKey,
-      secretKey: opts.secretKey
-    });
+// src/commands/connect/tools/index.ts
+var PLAN_MODE_ASK_QUESTION_HINT = `[SDK \u73AF\u5883\u8BF4\u660E]
+AskQuestion \u5DF2\u901A\u8FC7 MCP \u670D\u52A1\u5668 custom-user-tools \u6CE8\u518C\uFF0C\u5DE5\u5177\u540D\u4E3A AskQuestion\u3002
+\u9700\u8981\u5411\u7528\u6237\u786E\u8BA4\u65F6\uFF0C\u8BF7\u8C03\u7528 AskQuestion\uFF08\u7ECF CallMcpTool / custom-user-tools\uFF09\uFF0C\u4E0D\u8981\u5047\u8BBE IDE \u5185\u7F6E AskQuestion \u4E0D\u53EF\u7528\u3002
+\u975E\u5FC5\u987B\u7684\u95EE\u9898\u53EF\u8DF3\u8FC7\uFF0C\u76F4\u63A5\u5B8C\u6210 createPlan\u3002`;
+var WORKSPACE_BOUNDARY_HINT = `[\u5DE5\u4F5C\u533A\u8FB9\u754C]
+\u6240\u6709\u6587\u4EF6\u8BFB\u5199\u3001\u641C\u7D22\uFF08Grep/Glob/Read\uFF09\u3001Shell \u5FC5\u987B\u4E25\u683C\u9650\u5236\u5728\u5F53\u524D\u5DE5\u4F5C\u533A cwd \u5185\u3002
+\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 wantsTool(name, options, legacyDefault) {
+  if (options.toolNames !== void 0) {
+    return options.toolNames.includes(name);
   }
-  async ensureBucket(bucket) {
-    const exists = await this.inner.bucketExists(bucket);
-    if (!exists) {
-      await this.inner.makeBucket(bucket);
+  return legacyDefault;
+}
+function createCursorCustomTools(cfg2, options) {
+  const enableAppend = options.enableAppendMessage !== false && Boolean(options.appendMessageContent);
+  const enableAsk = options.enableAskQuestion !== false;
+  const enablePlan = options.enableWebIdePlanTools === true;
+  const enableMysql = options.enableMysqlTools === true;
+  const tools = {
+    ...wantsTool("AppendMessage", options, enableAppend) && options.appendMessageContent ? createAppendMessageCustomTools({
+      appendContent: options.appendMessageContent
+    }) : {},
+    ...wantsTool("AskQuestion", options, enableAsk) ? createAskQuestionTool({
+      onInvoke: options?.onAskQuestion,
+      execute: options?.askQuestionExecute
+    }) : {}
+  };
+  if (options?.taskId && options.workdir) {
+    const { cli } = createApmApiClient(cfg2);
+    const taskId = options.taskId;
+    if (wantsTool("RecommendPlan", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createRecommendPlanTool({
+          webideRecommendPlan: (args) => cli.webideRecommendPlan({ taskId, ...args })
+        })
+      );
     }
-  }
-  async putObject(bucket, objectKey, body, meta) {
-    await this.inner.putObject(bucket, objectKey, body, body.length, meta);
-  }
-  /** 大文件：从本地路径流式上传，避免整包读入内存 */
-  async fPutObject(bucket, objectKey, filePath, meta) {
-    await this.inner.fPutObject(bucket, objectKey, filePath, meta);
-  }
-  async listObjects(bucket, prefix) {
-    const objects = [];
-    const stream = this.inner.listObjectsV2(bucket, prefix, true);
-    await new Promise((resolve8, reject) => {
-      stream.on("data", (obj) => {
-        if (!obj.name) return;
-        objects.push({
-          name: obj.name,
-          size: typeof obj.size === "number" ? obj.size : 0,
-          lastModified: obj.lastModified ?? null,
-          ...typeof obj.etag === "string" ? { etag: obj.etag } : {}
-        });
-      });
-      stream.on("error", reject);
-      stream.on("end", () => resolve8());
-    });
-    return objects;
-  }
-  async statObject(bucket, objectKey) {
-    const stat = await this.inner.statObject(bucket, objectKey);
-    return {
-      size: typeof stat.size === "number" ? stat.size : 0,
-      metaData: stat.metaData
-    };
-  }
-  async removeObject(bucket, objectKey) {
-    await this.inner.removeObject(bucket, objectKey);
-  }
-  async getObjectBuffer(bucket, objectKey) {
-    const stream = await this.inner.getObject(bucket, objectKey);
-    const chunks = [];
-    for await (const chunk of stream) {
-      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    if (wantsTool("UpsertWebIdePlan", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createUpsertWebIdePlanTool({
+          webideUpsertPlan: (args) => cli.webideUpsertPlan({ taskId, ...args })
+        })
+      );
+    }
+    if (wantsTool("UpsertWebIdeChecklist", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createUpsertWebIdeChecklistTool({
+          webideUpsertChecklist: (args) => cli.webideUpsertChecklist({ taskId, ...args })
+        })
+      );
+    }
+    if (wantsTool("GetWebIdeChecklist", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createGetWebIdeChecklistTool({
+          boundTaskId: taskId,
+          webideGetChecklist: (args) => cli.webideGetChecklist(args)
+        })
+      );
+    }
+    if (wantsTool("UpsertWebIdeTestCases", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createUpsertWebIdeTestCasesTool({
+          webideReplaceTestCases: (args) => cli.webideReplaceTestCases({ taskId, ...args })
+        })
+      );
+    }
+    if (wantsTool("MergeWebIdePullRequests", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createMergeWebIdePullRequestsTool({
+          webideMergePullRequests: () => cli.webideMergePullRequests({ taskId })
+        })
+      );
+    }
+    if (wantsTool("MysqlExecute", options, enableMysql) && options.sqlExecutionId && options.workdir) {
+      Object.assign(
+        tools,
+        createMysqlExecuteTool({
+          taskId,
+          executionId: options.sqlExecutionId,
+          workdir: options.workdir,
+          upsertSqlExecution: (args) => cli.webideUpsertSqlExecution(args)
+        })
+      );
     }
-    return Buffer.concat(chunks);
   }
-};
-
-// src/commands/connect/apm-log-minio.ts
-async function fetchApmLogStorage(cfg2) {
-  const api = createApmApiClient(cfg2);
-  return api.cli.getApmLogStorage(void 0);
-}
-async function createApmLogMinioClient(cfg2) {
-  const storage = await fetchApmLogStorage(cfg2);
-  return {
-    client: new MinioClient({
-      endPoint: storage.endpoint,
-      port: storage.port,
-      useSSL: storage.useSsl,
-      accessKey: storage.accessKey,
-      secretKey: storage.secretKey
-    }),
-    bucket: storage.bucket,
-    ...storage.publicEndpoint ? { publicEndpoint: storage.publicEndpoint } : {}
-  };
+  return tools;
 }
+function withPlanModeToolHint(prompt, mode) {
+  if (mode !== "plan") {
+    return prompt;
+  }
+  return `${prompt.trim()}
 
-// src/commands/connect/sync-package-sql.ts
-var SKIP_DIR_NAMES2 = /* @__PURE__ */ new Set([
-  ".apm",
-  ".git",
-  ".idea",
-  ".vscode",
-  "node_modules",
-  "target",
-  "dist",
-  "build",
-  "out",
-  "coverage",
-  "__pycache__"
-]);
-function isSqlFileName(name) {
-  return name.toLowerCase().endsWith(".sql");
+${PLAN_MODE_ASK_QUESTION_HINT}`;
 }
-function sha256File(absPath) {
-  const hash = createHash("sha256");
-  hash.update(fs.readFileSync(absPath));
-  return hash.digest("hex");
+function withWorkspaceBoundaryHint(prompt) {
+  return `${prompt.trim()}
+
+${WORKSPACE_BOUNDARY_HINT}`;
 }
-function normalizeSqlRepoName(repo) {
-  const trimmed = repo.trim().replace(/\\/g, "/");
-  if (!trimmed) {
-    throw new Error("repo \u4E0D\u80FD\u4E3A\u7A7A");
-  }
-  if (trimmed.includes("/") || trimmed.includes("..") || trimmed === "." || trimmed.startsWith(".")) {
-    throw new Error(`\u65E0\u6548\u7684 repo \u540D: ${repo}`);
+
+// src/commands/connect/local-sqlite-agent-store.ts
+import {
+  composeLocalAgentStore
+} from "@cursor/sdk";
+import { SqliteLocalAgentStore } from "@cursor/sdk/sqlite";
+
+// src/commands/connect/remote-local-agent-store.ts
+function asCheckpointRef(value) {
+  if (value === void 0) return void 0;
+  if (value === null) return null;
+  if (!value || typeof value !== "object") return null;
+  const row = value;
+  if (typeof row.rootBlobId !== "string" || !row.rootBlobId.trim()) {
+    return null;
   }
-  return trimmed;
+  return {
+    schemaVersion: 1,
+    rootBlobId: row.rootBlobId
+  };
 }
-function scanSqlFilesUnderDir(localDir) {
-  const root = path.resolve(toFsPath(localDir));
-  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
-    throw new Error(`localDir \u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55: ${localDir}`);
-  }
-  const byRelative = /* @__PURE__ */ new Map();
-  const walk = (dir) => {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const name = entry.name;
-      if (entry.isDirectory()) {
-        if (SKIP_DIR_NAMES2.has(name) || name.startsWith(".")) continue;
-        walk(path.join(dir, name));
-        continue;
-      }
-      if (!entry.isFile() || !isSqlFileName(name)) continue;
-      const absPath = path.join(dir, name);
-      const relativePath = path.relative(root, absPath).replace(/\\/g, "/");
-      if (!relativePath || relativePath.includes("..")) continue;
-      const stat = fs.statSync(absPath);
-      if (!stat.isFile() || stat.size <= 0) continue;
-      byRelative.set(relativePath, {
-        absPath,
-        relativePath,
-        size: stat.size,
-        sha256: sha256File(absPath)
-      });
-    }
+function toApiCheckpointRef(ref) {
+  if (ref === void 0) return void 0;
+  if (ref === null) return null;
+  return {
+    schemaVersion: ref.schemaVersion,
+    rootBlobId: ref.rootBlobId
   };
-  walk(root);
-  return [...byRelative.values()].sort(
-    (a, b) => a.relativePath.localeCompare(b.relativePath)
-  );
-}
-function packageSqlObjectKey(projectId, repo, relativePath) {
-  return `packages/${projectId}/${repo}/${relativePath}`;
 }
-function packageSqlRepoPrefix(projectId, repo) {
-  return `packages/${projectId}/${repo}/`;
-}
-async function syncPackageSqlToMinio(params) {
-  const id = params.projectId.trim();
-  if (!id) {
-    throw new Error("projectId \u4E0D\u80FD\u4E3A\u7A7A");
-  }
-  const repo = normalizeSqlRepoName(params.repo);
-  const localFiles = scanSqlFilesUnderDir(params.localDir);
-  const { client, bucket } = await createApmLogMinioClient(params.cfg);
-  await client.ensureBucket(bucket);
-  const prefix = packageSqlRepoPrefix(id, repo);
-  const remoteObjects = await client.listObjects(bucket, prefix);
-  const remoteByRelative = /* @__PURE__ */ new Map();
-  for (const obj of remoteObjects) {
-    if (!obj.name.startsWith(prefix) || obj.name.endsWith("/")) continue;
-    if (!obj.name.toLowerCase().endsWith(".sql")) continue;
-    if (obj.name.includes("..")) continue;
-    const relativePath = obj.name.slice(prefix.length);
-    if (!relativePath) continue;
-    remoteByRelative.set(relativePath, {
-      objectKey: obj.name,
-      size: obj.size
-    });
-  }
-  for (const [relativePath, remote] of remoteByRelative) {
-    const local = localFiles.find((f) => f.relativePath === relativePath);
-    if (!local) continue;
-    if (local.size !== remote.size) continue;
-    try {
-      const stat = await client.statObject(bucket, remote.objectKey);
-      const meta = stat.metaData ?? {};
-      const sha = meta["sha256"] || meta["x-amz-meta-sha256"] || meta["Sha256"] || void 0;
-      if (typeof sha === "string" && sha.trim()) {
-        remote.sha256 = sha.trim().toLowerCase();
-      }
-    } catch {
-    }
-  }
-  let uploaded = 0;
-  let skipped = 0;
-  const localRelativeSet = new Set(localFiles.map((f) => f.relativePath));
-  for (const file of localFiles) {
-    const objectKey = packageSqlObjectKey(id, repo, file.relativePath);
-    const remote = remoteByRelative.get(file.relativePath);
-    if (remote?.sha256 && remote.sha256 === file.sha256) {
-      skipped += 1;
-      continue;
-    }
-    await client.fPutObject(bucket, objectKey, file.absPath, {
-      "Content-Type": "application/sql",
-      sha256: file.sha256
-    });
-    uploaded += 1;
-  }
-  let deleted = 0;
-  for (const [relativePath, remote] of remoteByRelative) {
-    if (localRelativeSet.has(relativePath)) continue;
-    await client.removeObject(bucket, remote.objectKey);
-    deleted += 1;
-  }
+function fromApiAgent(row) {
   return {
-    scanned: localFiles.length,
-    uploaded,
-    skipped,
-    deleted
+    agentId: row.agentId,
+    cwd: row.cwd,
+    status: row.status,
+    activeRunId: row.activeRunId,
+    name: row.name,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    latestCheckpoint: asCheckpointRef(row.latestCheckpoint) ?? null,
+    sdkMetadata: row.sdkMetadata ?? void 0
   };
 }
-
-// src/commands/connect/tools/package-sql-tool.ts
-function asString4(value) {
-  return typeof value === "string" ? value.trim() : "";
+function fromApiRun(row) {
+  return {
+    runId: row.runId,
+    requestId: row.requestId,
+    agentId: row.agentId,
+    turnNumber: row.turnNumber,
+    status: row.status,
+    model: row.model ?? null,
+    result: row.result,
+    error: row.error,
+    usageRef: row.usageRef,
+    usage: row.usage ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    startedAt: row.startedAt,
+    endedAt: row.endedAt,
+    startCheckpointRef: asCheckpointRef(row.startCheckpointRef) ?? null,
+    latestCheckpointRef: asCheckpointRef(row.latestCheckpointRef) ?? null
+  };
 }
-function resolveLocalSqlDir(workdir, localDirArg) {
-  if (!isAbsolute2(localDirArg)) {
-    return { ok: false, error: "localDir \u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84" };
+var unsupportedCheckpoints = {
+  async get() {
+    return null;
+  },
+  async create() {
+  },
+  async update() {
+  },
+  async delete() {
+  },
+  async list() {
+    return { items: [] };
   }
-  const workdirAbs = resolve5(toFsPath(workdir));
-  const targetAbs = resolve5(toFsPath(localDirArg));
-  const rel = relative3(workdirAbs, targetAbs);
-  if (!rel || rel.startsWith("..") || isAbsolute2(rel)) {
-    return { ok: false, error: "localDir \u5FC5\u987B\u4F4D\u4E8E\u5F53\u524D\u5DE5\u4F5C\u533A\u5185" };
+};
+var unsupportedRunEvents = {
+  async append() {
+    throw new Error("runEvents \u4EC5\u5B58\u672C\u673A SQLite");
+  },
+  async list() {
+    return { items: [] };
+  },
+  async delete() {
   }
-  const fsPath = toFsPath(targetAbs);
-  if (!existsSync4(fsPath)) {
-    return { ok: false, error: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${localDirArg}` };
+};
+function createRemoteLocalAgentStore(cfg2) {
+  const api = createApmApiClient(cfg2);
+  async function upsertAgent(agent) {
+    const row = await api.cli.cursorStoreUpsertAgent({
+      agentId: agent.agentId,
+      cwd: agent.cwd,
+      status: agent.status,
+      activeRunId: agent.activeRunId ?? null,
+      name: agent.name ?? null,
+      latestCheckpoint: toApiCheckpointRef(agent.latestCheckpoint) ?? null,
+      sdkMetadata: agent.sdkMetadata ?? null,
+      createdAt: agent.createdAt,
+      updatedAt: agent.updatedAt
+    });
+    return fromApiAgent(row);
   }
-  try {
-    if (!statSync4(fsPath).isDirectory()) {
-      return { ok: false, error: "localDir \u5FC5\u987B\u662F\u76EE\u5F55" };
-    }
-  } catch {
-    return { ok: false, error: `\u65E0\u6CD5\u8BFB\u53D6\u76EE\u5F55: ${localDirArg}` };
+  async function upsertRun(run) {
+    const row = await api.cli.cursorStoreUpsertRun({
+      runId: run.runId,
+      agentId: run.agentId,
+      requestId: run.requestId ?? null,
+      turnNumber: run.turnNumber,
+      status: run.status,
+      model: run.model ?? null,
+      result: run.result ?? null,
+      error: run.error ?? null,
+      usageRef: run.usageRef ?? null,
+      usage: run.usage ?? null,
+      startCheckpointRef: toApiCheckpointRef(run.startCheckpointRef) ?? null,
+      latestCheckpointRef: toApiCheckpointRef(run.latestCheckpointRef) ?? null,
+      createdAt: run.createdAt,
+      updatedAt: run.updatedAt,
+      startedAt: run.startedAt ?? null,
+      endedAt: run.endedAt ?? null
+    });
+    return fromApiRun(row);
   }
-  return { ok: true, absPath: targetAbs };
-}
-function createUploadPackageSqlTool(options) {
-  const { cfg: cfg2, workdir, projectId } = options;
   return {
-    UploadPackageSql: {
-      description: "Upload SQL scripts from a local directory to project MinIO mirror. Call after reading deploy docs: pass repo (directory name from\u300C\u8FDB\u5165 xxx \u76EE\u5F55\u300D) and localDir (absolute path to the SQL script directory). Syncs **/*.sql under localDir to packages/{projectId}/{repo}/.... Do not put SQL into jars.zip.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          repo: {
-            type: "string",
-            description: "Backend repo root directory name, e.g. mmis-java (from deploy\u300C\u8FDB\u5165 xxx \u76EE\u5F55\u300D)"
-          },
-          localDir: {
-            type: "string",
-            description: "Absolute path to the SQL script root directory under the workspace (deploy\u300CSQL\u811A\u672C\u76EE\u5F55\u300Dwithout the /**/*.sql suffix)"
-          }
-        },
-        required: ["repo", "localDir"]
+    agents: {
+      async get(input) {
+        const row = await api.cli.cursorStoreGetAgent({
+          agentId: input.agentId
+        });
+        return row ? fromApiAgent(row) : null;
       },
-      execute: async (args) => {
-        const repoRaw = asString4(args.repo);
-        const localDirRaw = asString4(args.localDir);
-        if (!repoRaw) {
-          return {
-            content: [{ type: "text", text: "repo \u4E0D\u80FD\u4E3A\u7A7A" }],
-            isError: true
-          };
+      async create(input) {
+        return upsertAgent(input.agent);
+      },
+      async update(input) {
+        return upsertAgent(input.agent);
+      },
+      async delete(input) {
+        const agentIds = input.filter.agentIds?.map((id) => id.trim()).filter(Boolean);
+        const cwd = input.filter.cwd?.trim();
+        if (agentIds && agentIds.length > 0) {
+          await api.cli.cursorStoreDeleteAgents({ agentIds, cwd });
+          return;
         }
-        if (!localDirRaw) {
-          return {
-            content: [{ type: "text", text: "localDir \u4E0D\u80FD\u4E3A\u7A7A" }],
-            isError: true
-          };
+        if (cwd) {
+          await api.cli.cursorStoreDeleteAgents({ cwd });
+          return;
         }
-        let repo;
-        try {
-          repo = normalizeSqlRepoName(repoRaw);
-        } catch (err) {
-          const detail = err instanceof Error ? err.message : String(err);
-          return {
-            content: [{ type: "text", text: detail }],
-            isError: true
-          };
+        let cursor;
+        for (; ; ) {
+          const page = await api.cli.cursorStoreListAgents({
+            cursor,
+            limit: 200
+          });
+          if (page.items.length === 0) break;
+          await api.cli.cursorStoreDeleteAgents({
+            agentIds: page.items.map((item) => item.agentId)
+          });
+          if (!page.nextCursor) break;
+          cursor = page.nextCursor;
         }
-        const resolved = resolveLocalSqlDir(workdir, localDirRaw);
-        if (!resolved.ok) {
-          return {
-            content: [{ type: "text", text: resolved.error }],
-            isError: true
-          };
+      },
+      async list(input) {
+        const page = await api.cli.cursorStoreListAgents({
+          cursor: input?.filter?.cursor,
+          limit: input?.filter?.limit,
+          cwd: input?.filter?.cwd
+        });
+        const result = {
+          items: page.items.map(fromApiAgent),
+          ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
+        };
+        return result;
+      }
+    },
+    runs: {
+      async get(input) {
+        const page = await api.cli.cursorStoreListRuns({
+          runIds: [input.runId],
+          limit: 1
+        });
+        const row = page.items[0];
+        return row ? fromApiRun(row) : null;
+      },
+      async create(input) {
+        return upsertRun(input.run);
+      },
+      async update(input) {
+        return upsertRun(input.run);
+      },
+      async delete(input) {
+        const agentIds = input.filter.agentIds?.map((id) => id.trim()).filter(Boolean);
+        const runIds = input.filter.runIds?.map((id) => id.trim()).filter(Boolean);
+        if (agentIds && agentIds.length > 0 || runIds && runIds.length > 0) {
+          await api.cli.cursorStoreDeleteRuns({ agentIds, runIds });
+          return;
         }
-        try {
-          const result = await syncPackageSqlToMinio({
-            cfg: cfg2,
-            projectId,
-            repo,
-            localDir: resolved.absPath
+        let cursor;
+        for (; ; ) {
+          const page = await api.cli.cursorStoreListRuns({
+            cursor,
+            limit: 200
           });
-          return `SQL \u5DF2\u540C\u6B65 repo=${repo} scanned=${result.scanned} uploaded=${result.uploaded} skipped=${result.skipped} deleted=${result.deleted}`;
-        } catch (err) {
-          const detail = err instanceof Error ? err.message : String(err);
-          return {
-            content: [{ type: "text", text: `\u4E0A\u4F20 SQL \u5931\u8D25: ${detail}` }],
-            isError: true
-          };
+          if (page.items.length === 0) break;
+          await api.cli.cursorStoreDeleteRuns({
+            runIds: page.items.map((item) => item.runId)
+          });
+          if (!page.nextCursor) break;
+          cursor = page.nextCursor;
         }
+      },
+      async list(input) {
+        const page = await api.cli.cursorStoreListRuns({
+          agentIds: input?.filter?.agentIds ? [...input.filter.agentIds] : void 0,
+          runIds: input?.filter?.runIds ? [...input.filter.runIds] : void 0,
+          cursor: input?.filter?.cursor,
+          limit: input?.filter?.limit
+        });
+        const result = {
+          items: page.items.map(fromApiRun),
+          ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
+        };
+        return result;
       }
-    }
+    },
+    checkpoints: unsupportedCheckpoints,
+    runEvents: unsupportedRunEvents
   };
 }
 
-// src/commands/connect/tools/package-status-tool.ts
-function createSetPackageFailedTool(options) {
-  const { packageId, setFailed } = options;
-  return {
-    SetPackageFailed: {
-      description: "\u6253\u5305\u5931\u8D25\u65F6\u8C03\u7528\uFF1A\u5C06\u5F53\u524D\u6253\u5305\u8BB0\u5F55\u6807\u4E3A FAILED\uFF0C\u5E76\u5199\u5165\u5931\u8D25\u539F\u56E0\u3002\u6784\u5EFA\u5931\u8D25\u3001\u7F3A\u4EA7\u7269\u3001\u6587\u6863\u7F3A\u5931\u7B49\u5747\u5E94\u8C03\u7528\uFF1B\u6210\u529F\u65F6\u4E0D\u8981\u8C03\u7528\u3002",
-      inputSchema: {
-        type: "object",
-        properties: {
-          error: {
-            type: "string",
-            description: "\u5931\u8D25\u539F\u56E0\u6458\u8981\uFF08\u4F1A\u5199\u5165\u6253\u5305\u8BB0\u5F55\uFF0C\u4F9B\u5217\u8868/\u65E5\u5FD7\u5C55\u793A\uFF09"
-          }
-        },
-        required: ["error"]
-      },
-      execute: async (args) => {
-        const error = typeof args.error === "string" ? args.error.trim() : "";
-        if (!error) {
-          return {
-            content: [{ type: "text", text: "error \u4E0D\u80FD\u4E3A\u7A7A" }],
-            isError: true
-          };
-        }
-        try {
-          await setFailed(error);
-          return `\u5DF2\u5C06\u6253\u5305\u8BB0\u5F55 ${packageId} \u6807\u4E3A FAILED`;
-        } catch (err) {
-          const detail = err instanceof Error ? err.message : String(err);
-          return {
-            content: [{ type: "text", text: `\u5199\u5165\u5931\u8D25\u72B6\u6001\u5931\u8D25: ${detail}` }],
-            isError: true
-          };
-        }
-      }
-    }
-  };
-}
-
-// src/commands/connect/tools/index.ts
-var PLAN_MODE_ASK_QUESTION_HINT = `[SDK \u73AF\u5883\u8BF4\u660E]
-AskQuestion \u5DF2\u901A\u8FC7 MCP \u670D\u52A1\u5668 custom-user-tools \u6CE8\u518C\uFF0C\u5DE5\u5177\u540D\u4E3A AskQuestion\u3002
-\u9700\u8981\u5411\u7528\u6237\u786E\u8BA4\u65F6\uFF0C\u8BF7\u8C03\u7528 AskQuestion\uFF08\u7ECF CallMcpTool / custom-user-tools\uFF09\uFF0C\u4E0D\u8981\u5047\u8BBE IDE \u5185\u7F6E AskQuestion \u4E0D\u53EF\u7528\u3002
-\u975E\u5FC5\u987B\u7684\u95EE\u9898\u53EF\u8DF3\u8FC7\uFF0C\u76F4\u63A5\u5B8C\u6210 createPlan\u3002`;
-var WORKSPACE_BOUNDARY_HINT = `[\u5DE5\u4F5C\u533A\u8FB9\u754C]
-\u6240\u6709\u6587\u4EF6\u8BFB\u5199\u3001\u641C\u7D22\uFF08Grep/Glob/Read\uFF09\u3001Shell \u5FC5\u987B\u4E25\u683C\u9650\u5236\u5728\u5F53\u524D\u5DE5\u4F5C\u533A cwd \u5185\u3002
-\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 wantsTool(name, options, legacyDefault) {
-  if (options.toolNames !== void 0) {
-    return options.toolNames.includes(name);
-  }
-  return legacyDefault;
-}
-function createCursorCustomTools(cfg2, options) {
-  const enableAppend = options.enableAppendMessage !== false && Boolean(options.appendMessageContent);
-  const enableAsk = options.enableAskQuestion !== false;
-  const enablePlan = options.enableWebIdePlanTools === true;
-  const enableMysql = options.enableMysqlTools === true;
-  const tools = {
-    ...wantsTool("AppendMessage", options, enableAppend) && options.appendMessageContent ? createAppendMessageCustomTools({
-      appendContent: options.appendMessageContent
-    }) : {},
-    ...wantsTool("AskQuestion", options, enableAsk) ? createAskQuestionTool({
-      onInvoke: options?.onAskQuestion,
-      execute: options?.askQuestionExecute
-    }) : {}
-  };
-  if (options?.taskId && options.workdir) {
-    const { cli } = createApmApiClient(cfg2);
-    const taskId = options.taskId;
-    if (wantsTool("RecommendPlan", options, enablePlan)) {
-      Object.assign(
-        tools,
-        createRecommendPlanTool({
-          webideRecommendPlan: (args) => cli.webideRecommendPlan({ taskId, ...args })
-        })
-      );
-    }
-    if (wantsTool("UpsertWebIdePlan", options, enablePlan)) {
-      Object.assign(
-        tools,
-        createUpsertWebIdePlanTool({
-          webideUpsertPlan: (args) => cli.webideUpsertPlan({ taskId, ...args })
-        })
-      );
-    }
-    if (wantsTool("UpsertWebIdeChecklist", options, enablePlan)) {
-      Object.assign(
-        tools,
-        createUpsertWebIdeChecklistTool({
-          webideUpsertChecklist: (args) => cli.webideUpsertChecklist({ taskId, ...args })
-        })
-      );
-    }
-    if (wantsTool("GetWebIdeChecklist", options, enablePlan)) {
-      Object.assign(
-        tools,
-        createGetWebIdeChecklistTool({
-          boundTaskId: taskId,
-          webideGetChecklist: (args) => cli.webideGetChecklist(args)
-        })
-      );
-    }
-    if (wantsTool("UpsertWebIdeTestCases", options, enablePlan)) {
-      Object.assign(
-        tools,
-        createUpsertWebIdeTestCasesTool({
-          webideReplaceTestCases: (args) => cli.webideReplaceTestCases({ taskId, ...args })
-        })
-      );
-    }
-    if (wantsTool("MergeWebIdePullRequests", options, enablePlan)) {
-      Object.assign(
-        tools,
-        createMergeWebIdePullRequestsTool({
-          webideMergePullRequests: () => cli.webideMergePullRequests({ taskId })
-        })
-      );
-    }
-    if (wantsTool("MysqlExecute", options, enableMysql) && options.sqlExecutionId && options.workdir) {
-      Object.assign(
-        tools,
-        createMysqlExecuteTool({
-          taskId,
-          executionId: options.sqlExecutionId,
-          workdir: options.workdir,
-          upsertSqlExecution: (args) => cli.webideUpsertSqlExecution(args)
-        })
-      );
-    }
-  }
-  if (options.enablePackageStatusTools && options.packageId) {
-    const packageId = options.packageId;
-    const { cli } = createApmApiClient(cfg2);
-    Object.assign(
-      tools,
-      createSetPackageFailedTool({
-        packageId,
-        setFailed: async (error) => {
-          await cli.projectPackageUpdateStatus({
-            id: packageId,
-            status: "FAILED",
-            error
-          });
-          await options.onPackageFailed?.(error);
-        }
-      })
-    );
-    const projectId = options.projectId?.trim();
-    if (projectId && options.workdir) {
-      Object.assign(
-        tools,
-        createUploadPackageSqlTool({
-          cfg: cfg2,
-          workdir: options.workdir,
-          projectId
-        })
-      );
-    }
-  }
-  return tools;
-}
-function withPlanModeToolHint(prompt, mode) {
-  if (mode !== "plan") {
-    return prompt;
-  }
-  return `${prompt.trim()}
-
-${PLAN_MODE_ASK_QUESTION_HINT}`;
-}
-function withWorkspaceBoundaryHint(prompt) {
-  return `${prompt.trim()}
-
-${WORKSPACE_BOUNDARY_HINT}`;
-}
-
-// src/commands/connect/mcps/pty-session-mcp.ts
-var PTY_SESSION_MCP_NAME = "pty-session";
-var DEFAULT_PTY_SESSION_PORT = "7788";
-function resolvePtySessionBaseUrl(env = process.env) {
-  const explicit = env.LOCAL_TERMINAL_URL?.trim();
-  if (explicit) return explicit.replace(/\/+$/, "");
-  const port2 = env.LOCAL_TERMINAL_PORT?.trim() || DEFAULT_PTY_SESSION_PORT;
-  return `http://127.0.0.1:${port2}`;
-}
-function createPtySessionMcpServers(cfg2) {
-  const token = resolveApiKey(cfg2);
-  if (!token) return void 0;
-  return {
-    [PTY_SESSION_MCP_NAME]: {
-      type: "http",
-      url: `${resolvePtySessionBaseUrl()}/mcp`,
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    }
-  };
-}
-
-// src/commands/connect/local-sqlite-agent-store.ts
-import {
-  composeLocalAgentStore
-} from "@cursor/sdk";
-import { SqliteLocalAgentStore } from "@cursor/sdk/sqlite";
-
-// src/commands/connect/remote-local-agent-store.ts
-function asCheckpointRef(value) {
-  if (value === void 0) return void 0;
-  if (value === null) return null;
-  if (!value || typeof value !== "object") return null;
-  const row = value;
-  if (typeof row.rootBlobId !== "string" || !row.rootBlobId.trim()) {
-    return null;
-  }
-  return {
-    schemaVersion: 1,
-    rootBlobId: row.rootBlobId
-  };
-}
-function toApiCheckpointRef(ref) {
-  if (ref === void 0) return void 0;
-  if (ref === null) return null;
-  return {
-    schemaVersion: ref.schemaVersion,
-    rootBlobId: ref.rootBlobId
-  };
-}
-function fromApiAgent(row) {
-  return {
-    agentId: row.agentId,
-    cwd: row.cwd,
-    status: row.status,
-    activeRunId: row.activeRunId,
-    name: row.name,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-    latestCheckpoint: asCheckpointRef(row.latestCheckpoint) ?? null,
-    sdkMetadata: row.sdkMetadata ?? void 0
-  };
-}
-function fromApiRun(row) {
-  return {
-    runId: row.runId,
-    requestId: row.requestId,
-    agentId: row.agentId,
-    turnNumber: row.turnNumber,
-    status: row.status,
-    model: row.model ?? null,
-    result: row.result,
-    error: row.error,
-    usageRef: row.usageRef,
-    usage: row.usage ?? null,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-    startedAt: row.startedAt,
-    endedAt: row.endedAt,
-    startCheckpointRef: asCheckpointRef(row.startCheckpointRef) ?? null,
-    latestCheckpointRef: asCheckpointRef(row.latestCheckpointRef) ?? null
-  };
-}
-var unsupportedCheckpoints = {
-  async get() {
-    return null;
-  },
-  async create() {
-  },
-  async update() {
-  },
-  async delete() {
-  },
-  async list() {
-    return { items: [] };
-  }
-};
-var unsupportedRunEvents = {
-  async append() {
-    throw new Error("runEvents \u4EC5\u5B58\u672C\u673A SQLite");
-  },
-  async list() {
-    return { items: [] };
-  },
-  async delete() {
-  }
-};
-function createRemoteLocalAgentStore(cfg2) {
-  const api = createApmApiClient(cfg2);
-  async function upsertAgent(agent) {
-    const row = await api.cli.cursorStoreUpsertAgent({
-      agentId: agent.agentId,
-      cwd: agent.cwd,
-      status: agent.status,
-      activeRunId: agent.activeRunId ?? null,
-      name: agent.name ?? null,
-      latestCheckpoint: toApiCheckpointRef(agent.latestCheckpoint) ?? null,
-      sdkMetadata: agent.sdkMetadata ?? null,
-      createdAt: agent.createdAt,
-      updatedAt: agent.updatedAt
-    });
-    return fromApiAgent(row);
-  }
-  async function upsertRun(run) {
-    const row = await api.cli.cursorStoreUpsertRun({
-      runId: run.runId,
-      agentId: run.agentId,
-      requestId: run.requestId ?? null,
-      turnNumber: run.turnNumber,
-      status: run.status,
-      model: run.model ?? null,
-      result: run.result ?? null,
-      error: run.error ?? null,
-      usageRef: run.usageRef ?? null,
-      usage: run.usage ?? null,
-      startCheckpointRef: toApiCheckpointRef(run.startCheckpointRef) ?? null,
-      latestCheckpointRef: toApiCheckpointRef(run.latestCheckpointRef) ?? null,
-      createdAt: run.createdAt,
-      updatedAt: run.updatedAt,
-      startedAt: run.startedAt ?? null,
-      endedAt: run.endedAt ?? null
-    });
-    return fromApiRun(row);
-  }
-  return {
-    agents: {
-      async get(input) {
-        const row = await api.cli.cursorStoreGetAgent({
-          agentId: input.agentId
-        });
-        return row ? fromApiAgent(row) : null;
-      },
-      async create(input) {
-        return upsertAgent(input.agent);
-      },
-      async update(input) {
-        return upsertAgent(input.agent);
-      },
-      async delete(input) {
-        const agentIds = input.filter.agentIds?.map((id) => id.trim()).filter(Boolean);
-        const cwd = input.filter.cwd?.trim();
-        if (agentIds && agentIds.length > 0) {
-          await api.cli.cursorStoreDeleteAgents({ agentIds, cwd });
-          return;
-        }
-        if (cwd) {
-          await api.cli.cursorStoreDeleteAgents({ cwd });
-          return;
-        }
-        let cursor;
-        for (; ; ) {
-          const page = await api.cli.cursorStoreListAgents({
-            cursor,
-            limit: 200
-          });
-          if (page.items.length === 0) break;
-          await api.cli.cursorStoreDeleteAgents({
-            agentIds: page.items.map((item) => item.agentId)
-          });
-          if (!page.nextCursor) break;
-          cursor = page.nextCursor;
-        }
-      },
-      async list(input) {
-        const page = await api.cli.cursorStoreListAgents({
-          cursor: input?.filter?.cursor,
-          limit: input?.filter?.limit,
-          cwd: input?.filter?.cwd
-        });
-        const result = {
-          items: page.items.map(fromApiAgent),
-          ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
-        };
-        return result;
-      }
-    },
-    runs: {
-      async get(input) {
-        const page = await api.cli.cursorStoreListRuns({
-          runIds: [input.runId],
-          limit: 1
-        });
-        const row = page.items[0];
-        return row ? fromApiRun(row) : null;
-      },
-      async create(input) {
-        return upsertRun(input.run);
-      },
-      async update(input) {
-        return upsertRun(input.run);
-      },
-      async delete(input) {
-        const agentIds = input.filter.agentIds?.map((id) => id.trim()).filter(Boolean);
-        const runIds = input.filter.runIds?.map((id) => id.trim()).filter(Boolean);
-        if (agentIds && agentIds.length > 0 || runIds && runIds.length > 0) {
-          await api.cli.cursorStoreDeleteRuns({ agentIds, runIds });
-          return;
-        }
-        let cursor;
-        for (; ; ) {
-          const page = await api.cli.cursorStoreListRuns({
-            cursor,
-            limit: 200
-          });
-          if (page.items.length === 0) break;
-          await api.cli.cursorStoreDeleteRuns({
-            runIds: page.items.map((item) => item.runId)
-          });
-          if (!page.nextCursor) break;
-          cursor = page.nextCursor;
-        }
-      },
-      async list(input) {
-        const page = await api.cli.cursorStoreListRuns({
-          agentIds: input?.filter?.agentIds ? [...input.filter.agentIds] : void 0,
-          runIds: input?.filter?.runIds ? [...input.filter.runIds] : void 0,
-          cursor: input?.filter?.cursor,
-          limit: input?.filter?.limit
-        });
-        const result = {
-          items: page.items.map(fromApiRun),
-          ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
-        };
-        return result;
-      }
-    },
-    checkpoints: unsupportedCheckpoints,
-    runEvents: unsupportedRunEvents
-  };
-}
-
-// src/commands/connect/local-sqlite-agent-store.ts
-var sqliteByKey = /* @__PURE__ */ new Map();
-async function openSqliteLocalAgentStore(workspaceRef) {
-  const cwd = workspaceRef.trim();
-  if (!cwd) throw new Error("openSqliteLocalAgentStore: workspaceRef \u4E0D\u80FD\u4E3A\u7A7A");
-  const existing = sqliteByKey.get(cwd);
-  if (existing) return existing;
-  const pending2 = SqliteLocalAgentStore.open({ workspaceRef: cwd }).then(
-    (store) => {
-      console.log(
-        `[apm] Cursor store sqlite ready cwd=${cwd} stateRoot=${store.stateRoot}`
-      );
-      return store;
-    }
-  );
-  sqliteByKey.set(cwd, pending2);
-  return pending2;
-}
-function jsonSafePayload(value) {
-  if (value == null) return null;
-  try {
-    return JSON.parse(JSON.stringify(value));
-  } catch {
-    return null;
-  }
-}
-function mirrorRunEventsForVisualization(cfg2, local) {
-  const api = createApmApiClient(cfg2);
-  return {
-    async append(input) {
-      const row = await local.append(input);
-      try {
-        await api.cli.cursorStoreAppendRunEvents({
-          events: [
-            {
-              runId: input.runId,
-              eventType: input.eventType,
-              payload: jsonSafePayload(input.payload),
-              payloadRef: input.payloadRef ?? null,
-              idempotencyKey: input.idempotencyKey ?? `${input.runId}:${row.seq}`,
-              createdAt: row.createdAt
-            }
-          ]
-        });
-      } catch (err) {
-        console.warn(
-          `[apm] runEvents \u53EF\u89C6\u5316\u540C\u6B65\u8DF3\u8FC7 runId=${input.runId} seq=${row.seq}:`,
-          err instanceof Error ? err.message : err
-        );
-      }
-      return row;
-    },
-    list: (input) => local.list(input),
-    async delete(input) {
-      await local.delete(input);
-      const runIds = input.filter.runIds?.map((id) => id.trim()).filter(Boolean);
-      if (!runIds?.length) return;
-      try {
-        await api.cli.cursorStoreDeleteRunEvents({ runIds });
-      } catch (err) {
-        console.warn(
-          `[apm] runEvents \u53EF\u89C6\u5316\u6E05\u7406\u8DF3\u8FC7:`,
-          err instanceof Error ? err.message : err
-        );
-      }
-    }
-  };
-}
-async function createApmCursorAgentStore(cfg2, workspaceRef) {
-  const cwd = workspaceRef.trim();
-  const [sqlite, remote] = await Promise.all([
-    openSqliteLocalAgentStore(cwd),
-    Promise.resolve(createRemoteLocalAgentStore(cfg2))
-  ]);
-  return composeLocalAgentStore({
-    agents: remote.agents,
-    runs: remote.runs,
-    checkpoints: sqlite.checkpoints,
-    runEvents: mirrorRunEventsForVisualization(cfg2, sqlite.runEvents)
-  });
-}
-async function purgeLocalSqliteAgentData(input) {
-  const agentId = input.agentId.trim();
-  const workspaceRef = input.workspaceRef.trim();
-  if (!agentId || !workspaceRef) return;
-  const sqlite = await openSqliteLocalAgentStore(workspaceRef);
-  const runIds = [...input.runIds ?? []];
-  if (runIds.length > 0) {
-    await sqlite.runEvents.delete({ filter: { runIds } });
-  }
-  await sqlite.checkpoints.delete({ filter: { agentIds: [agentId] } });
-}
-
-// src/commands/connect/core/worker/run-steer.ts
-var impl = null;
-var pending = null;
-function bindRunSteer(fn) {
-  impl = fn;
-  if (!pending) return;
-  const text = pending;
-  pending = null;
-  void fn(text);
-}
-function clearRunSteer() {
-  impl = null;
-  pending = null;
-}
-function deliverRunSteer(text) {
-  const trimmed = text.trim();
-  if (!trimmed) return;
-  if (impl) {
-    void impl(trimmed);
-    return;
-  }
-  pending = trimmed;
-}
-
-// src/commands/connect/cursor-agent.ts
-var noopRemoteLogSync = {
-  schedule(_session) {
-  },
-  async flush(_session) {
-  }
-};
-function formatCursorRunFailure(runId, options) {
-  const details = [
-    options?.statusError?.trim(),
-    options?.resultText?.trim()
-  ].filter((value, index, arr) => {
-    if (!value) return false;
-    return arr.indexOf(value) === index;
-  });
-  if (details.length === 0) {
-    return `Cursor run \u5931\u8D25: ${runId}`;
-  }
-  return `Cursor run \u5931\u8D25: ${runId} \u2014 ${details.join("\uFF1B")}`;
-}
-async function obtainAgent(ctx) {
-  const store = await createApmCursorAgentStore(ctx.cfg, ctx.cwd);
-  const agentOptions = {
-    apiKey: ctx.apiKey,
-    model: { id: ctx.model || "default" },
-    local: {
-      cwd: ctx.cwd,
-      store,
-      ...ctx.customTools ? { customTools: ctx.customTools } : {},
-      ...ctx.enableSandbox ? {
-        sandboxOptions: { enabled: true },
-        // 只加载项目级设置，避免 ~/.cursor/mcp.json 里需 OAuth/审批的 MCP 在无头沙箱被拒
-        settingSources: ["project"]
-      } : {}
-    },
-    ...ctx.mode ? { mode: ctx.mode } : {},
-    ...ctx.mcpServers ? { mcpServers: ctx.mcpServers } : {}
-  };
-  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}`);
-      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
-      );
-      ctx.onInvalidatePersistedAgentId?.();
-    }
-  }
-  try {
-    const agent = await Agent.create(agentOptions);
-    return { agent, resumed: false };
-  } catch (err) {
-    if (ctx.enableSandbox && err instanceof Error && /sandbox/i.test(err.message)) {
-      console.warn("[apm] sandbox \u4E0D\u53EF\u7528\uFF0C\u56DE\u9000\u4E3A\u65E0 sandbox:", err.message);
-      return obtainAgent({ ...ctx, enableSandbox: false });
-    }
-    throw err;
-  }
-}
-async function runCursorAgent(cfg2, ctx, options) {
-  const signal = options.signal;
-  if (signal?.aborted) {
-    throw new Error("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u4EFB\u52A1\u4E2D\u65AD");
-  }
-  const apiKey = ctx.apiKey.trim();
-  if (!apiKey) {
-    throw new Error("\u7F3A\u5C11 apiKey\uFF0C\u65E0\u6CD5\u8C03\u7528 Cursor SDK");
-  }
-  const workdir = resolveWorkdirPath(ctx.workdir);
-  const customTools = createCursorCustomTools(cfg2, {
-    onAskQuestion: options.onAskQuestion,
-    appendMessageContent: options.appendMessageContent,
-    enableAppendMessage: options.enableAppendMessage,
-    enableAskQuestion: options.enableAskQuestion,
-    askQuestionExecute: options.askQuestionExecute,
-    enableWebIdePlanTools: options.enableWebIdePlanTools,
-    enableMysqlTools: options.enableMysqlTools,
-    sqlExecutionId: options.sqlExecutionId,
-    toolNames: options.toolNames,
-    taskId: options.taskId,
-    workdir,
-    enablePackageStatusTools: options.enablePackageStatusTools,
-    packageId: options.packageId,
-    projectId: options.projectId,
-    onPackageFailed: options.onPackageFailed
-  });
-  const enableSandbox = Boolean(options.enableSandbox);
-  const mcpServers = options.enablePtySessionMcp ? createPtySessionMcpServers(cfg2) : void 0;
-  let prompt = withPlanModeToolHint(ctx.prompt, ctx.mode);
-  prompt = withWorkspaceBoundaryHint(prompt);
-  console.log(
-    `[apm] Cursor Agent \u5F00\u59CB messageId=${ctx.messageId} cwd=${workdir} sandbox=${enableSandbox}`
-  );
-  const { agent, resumed } = await obtainAgent({
-    cfg: cfg2,
-    apiKey,
-    model: ctx.model,
-    cwd: workdir,
-    user: ctx.user,
-    mode: ctx.mode,
-    resumeAgentId: ctx.resumeAgentId,
-    customTools,
-    enableSandbox,
-    mcpServers,
-    onInvalidatePersistedAgentId: options.onInvalidatePersistedAgentId
-  });
-  const invalidateAgentMapping = () => {
-    options.onInvalidatePersistedAgentId?.();
-  };
-  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;
-    void activeRun.cancel().catch(() => void 0);
-  };
-  signal?.addEventListener("abort", abortRun, { once: true });
-  try {
-    const run = await agent.send(prompt, {
-      ...ctx.mode ? { mode: ctx.mode } : {},
-      local: {
-        ...options.forceSend ? { force: true } : {},
-        customTools
-      }
-    });
-    activeRun = run;
-    console.log(`[apm] Cursor run id=${run.id} agentId=${agent.agentId}`);
-    bindRunSteer(async (text) => {
-      const steer = run.steer;
-      if (!steer) {
-        console.warn(`[apm] \u5F53\u524D run \u4E0D\u652F\u6301 steer runId=${run.id}`);
-        return;
-      }
-      try {
-        const outcome = await steer(text);
-        console.log(`[apm] steer outcome=${outcome} runId=${run.id}`);
-      } catch (err) {
-        console.error(
-          `[apm] steer \u5931\u8D25 runId=${run.id}:`,
-          err instanceof Error ? err.message : err
-        );
-      }
-    });
-    await options.onRunStarted?.({ agentId: agent.agentId, runId: run.id });
-    let lastRunErrorStatus;
-    for await (const event of run.stream()) {
-      if (signal?.aborted) {
-        abortRun();
-        throw new Error("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u4EFB\u52A1\u4E2D\u65AD");
-      }
-      if (event.type === "status" && event.status === "ERROR") {
-        const message = event.message?.trim();
-        if (message) {
-          lastRunErrorStatus = message;
-          console.error(
-            `[apm] Cursor run status=ERROR runId=${run.id}: ${message}`
-          );
-        }
-      }
-      options.onStreamEvent?.(event);
-      eventSession.addEvent(event);
-      syncRemoteLog.schedule(eventSession);
-    }
-    await syncRemoteLog.flush(eventSession);
-    const result = await run.wait();
-    if (result.usage) {
-      eventSession.addRunUsage(result.usage, {
-        durationMs: result.durationMs
-      });
-      await syncRemoteLog.flush(eventSession);
-      console.log(
-        `[apm] Cursor usage total=${result.usage.totalTokens} in=${result.usage.inputTokens} out=${result.usage.outputTokens} cache=${result.usage.cacheReadTokens}/${result.usage.cacheWriteTokens}`
-      );
-    }
-    if (result.status === "error") {
-      const failureMessage = formatCursorRunFailure(result.id, {
-        statusError: lastRunErrorStatus,
-        resultText: result.result
-      });
-      console.error(`[apm] ${failureMessage}`);
-      if (resumed) {
-        invalidateAgentMapping();
-      }
-      throw new Error(failureMessage);
-    }
-    if (result.status === "cancelled") {
-      throw new Error(`Cursor run \u5DF2\u53D6\u6D88: ${result.id}`);
-    }
-    console.log(`[apm] Cursor Agent \u5B8C\u6210 messageId=${ctx.messageId}`);
-    const artifacts = await agent.listArtifacts().catch(() => []);
-    const artifactDocuments = [];
-    for (const artifact of artifacts) {
-      try {
-        const content = (await agent.downloadArtifact(artifact.path)).toString(
-          "utf8"
-        );
-        artifactDocuments.push({ path: artifact.path, content });
-      } catch (err) {
-        console.warn(
-          `[apm] \u8BFB\u53D6\u4EA7\u7269\u5931\u8D25 path=${artifact.path}:`,
-          err instanceof Error ? err.message : err
-        );
-      }
-    }
-    return {
-      runId: result.id,
-      agentId: agent.agentId,
-      status: result.status,
-      result: result.result,
-      durationMs: result.durationMs,
-      usage: result.usage,
-      modelId: result.model?.id?.trim() || ctx.model?.trim() || void 0,
-      assistantText: eventSession.getAssistantText(),
-      createPlan: eventSession.getCreatePlanContent(),
-      artifacts,
-      artifactDocuments
-    };
-  } catch (err) {
-    if (err instanceof CursorAgentError) {
-      if (resumed) {
-        invalidateAgentMapping();
-      }
-      throw new Error(
-        `Cursor \u542F\u52A8\u5931\u8D25: ${err.message}${err.isRetryable ? "\uFF08\u53EF\u91CD\u8BD5\uFF09" : ""}`
-      );
-    }
-    throw err;
-  } finally {
-    clearRunSteer();
-    signal?.removeEventListener("abort", abortRun);
-    await agent[Symbol.asyncDispose]();
-  }
-}
-
-// src/commands/connect/webide-message-log.ts
-var SYNC_INTERVAL_MS = 2e3;
-function webIdeEventsObjectPrefix(taskId, messageId) {
-  return `events/webide/${taskId}/${messageId}/`;
-}
-async function putDirtyEvents(minio, bucket, prefix, events) {
-  for (const event of events) {
-    const key = `${prefix}${event.index}.json`;
-    const body = Buffer.from(
-      JSON.stringify({
-        index: event.index,
-        type: event.type,
-        data: event.data
-      }),
-      "utf8"
-    );
-    await minio.putObject(bucket, key, body, {
-      "Content-Type": "application/json"
-    });
-  }
-}
-async function upsertLogHeader(cfg2, ctx, patch, objectPrefix) {
-  const api = createApmApiClient(cfg2);
-  await api.cli.webideUpsertMessageLog({
-    messageId: ctx.messageId,
-    agentId: ctx.agentId,
-    objectPrefix,
-    ...patch
-  });
-}
-function createThrottledWebIdeMessageLogSync(cfg2, ctx, onError, options) {
-  let lastRunAt = 0;
-  let timer;
-  let latestSession;
-  let syncChain = Promise.resolve();
-  let minio;
-  let bucket = "";
-  let firstLogNotified = false;
-  const resolvePrefix = () => options?.objectPrefixOverride?.trim() || webIdeEventsObjectPrefix(ctx.taskId, ctx.messageId);
-  const ensureMinio = async () => {
-    if (minio) return;
-    const created = await createApmLogMinioClient(cfg2);
-    minio = created.client;
-    bucket = created.bucket;
-    await minio.ensureBucket(bucket);
-  };
-  const notifyFirstLog = async () => {
-    if (firstLogNotified) return;
-    firstLogNotified = true;
-    try {
-      await options?.onFirstLogSynced?.();
-    } catch (err) {
-      firstLogNotified = false;
-      onError(err);
-    }
-  };
-  const syncDirtyEventsOnce = async (session) => {
-    const events = session.getDirtyEvents();
-    if (events.length === 0) return;
-    lastRunAt = Date.now();
-    try {
-      await ensureMinio();
-      const prefix = resolvePrefix();
-      await putDirtyEvents(minio, bucket, prefix, events);
-      await upsertLogHeader(
-        cfg2,
-        ctx,
-        {
-          eventCount: session.getEventCount()
-        },
-        prefix
+// src/commands/connect/local-sqlite-agent-store.ts
+var sqliteByKey = /* @__PURE__ */ new Map();
+async function openSqliteLocalAgentStore(workspaceRef) {
+  const cwd = workspaceRef.trim();
+  if (!cwd) throw new Error("openSqliteLocalAgentStore: workspaceRef \u4E0D\u80FD\u4E3A\u7A7A");
+  const existing = sqliteByKey.get(cwd);
+  if (existing) return existing;
+  const pending2 = SqliteLocalAgentStore.open({ workspaceRef: cwd }).then(
+    (store) => {
+      console.log(
+        `[apm] Cursor store sqlite ready cwd=${cwd} stateRoot=${store.stateRoot}`
       );
-      session.clearDirtyIfUnchanged(events);
-      await notifyFirstLog();
-    } 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 {
-    async markRun(runId, runStatus, lastError, tokenUsage) {
-      try {
-        await upsertLogHeader(
-          cfg2,
-          ctx,
-          {
-            runId,
-            runStatus,
-            lastError: lastError ?? null,
-            ...tokenUsage ? { tokenUsage } : {}
-          },
-          resolvePrefix()
-        );
-      } catch (err) {
-        onError(err);
-      }
-    },
-    schedule(session) {
-      latestSession = session;
-      const now = Date.now();
-      const elapsed = now - lastRunAt;
-      if (elapsed >= SYNC_INTERVAL_MS) {
-        if (timer) {
-          clearTimeout(timer);
-          timer = void 0;
-        }
-        enqueueSync(session);
-        return;
-      }
-      if (timer) return;
-      timer = setTimeout(() => {
-        timer = void 0;
-        if (latestSession) enqueueSync(latestSession);
-      }, SYNC_INTERVAL_MS - elapsed);
-    },
-    async flush(session) {
-      if (timer) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-      await syncChain;
-      await drainDirtyEvents(session);
+      return store;
     }
-  };
-}
-
-// src/commands/sync-webide-agent.ts
-import {
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync4,
-  unlinkSync,
-  writeFileSync as writeFileSync3
-} from "fs";
-import { join as join4 } from "path";
-var REVISION_FILE = ".webide-agent.json";
-var RULE_KEY = /^[a-z0-9_]+$/;
-function withTrailingNewline(text) {
-  return text.endsWith("\n") ? text : `${text}
-`;
+  );
+  sqliteByKey.set(cwd, pending2);
+  return pending2;
 }
-function readRevision(apmDir) {
-  const path3 = toFsPath(join4(apmDir, REVISION_FILE));
-  if (!existsSync5(path3)) return null;
+function jsonSafePayload(value) {
+  if (value == null) return null;
   try {
-    const parsed = JSON.parse(readFileSync4(path3, "utf8"));
-    if (parsed?.version === 1 && parsed.revision?.trim()) {
-      return parsed.revision.trim();
-    }
+    return JSON.parse(JSON.stringify(value));
   } catch {
     return null;
   }
-  return null;
-}
-function writeRevision(apmDir, revision) {
-  writeFileSync3(
-    toFsPath(join4(apmDir, REVISION_FILE)),
-    `${JSON.stringify({ version: 1, revision }, null, 2)}
-`,
-    "utf8"
-  );
 }
-async function syncWebIdeAgentFiles(workdir, cfg2) {
+function mirrorRunEventsForVisualization(cfg2, local) {
   const api = createApmApiClient(cfg2);
-  const bundle = await api.cli.webideAgentConfig();
-  const revision = bundle.revision?.trim();
-  if (!revision) {
-    throw new Error("[apm] \u5E73\u53F0\u672A\u8FD4\u56DE WebIDE \u89C4\u5219\u7248\u672C");
-  }
-  const apmDir = workspaceApmDir(workdir);
-  mkdirSync4(toFsPath(apmDir), { recursive: true });
-  if (readRevision(apmDir) === revision) {
-    return { revision, wrote: false, ruleCount: bundle.rules?.length ?? 0 };
-  }
-  const rulesDir = join4(apmDir, "rules");
-  mkdirSync4(toFsPath(rulesDir), { recursive: true });
-  writeFileSync3(
-    toFsPath(join4(apmDir, "AGENTS.md")),
-    withTrailingNewline(bundle.guide ?? ""),
-    "utf8"
-  );
-  const keep = /* @__PURE__ */ new Set();
-  for (const rule of bundle.rules ?? []) {
-    const key = rule.key?.trim() ?? "";
-    if (!RULE_KEY.test(key)) {
-      throw new Error(`[apm] \u975E\u6CD5\u89C4\u5219\u540D: ${key || "(\u7A7A)"}`);
-    }
-    keep.add(`${key}.md`);
-    writeFileSync3(
-      toFsPath(join4(rulesDir, `${key}.md`)),
-      withTrailingNewline(rule.body ?? ""),
-      "utf8"
-    );
-  }
-  for (const name of readdirSync3(toFsPath(rulesDir))) {
-    if (!name.endsWith(".md")) continue;
-    if (keep.has(name)) continue;
-    unlinkSync(toFsPath(join4(rulesDir, name)));
-  }
-  writeRevision(apmDir, revision);
   return {
-    revision,
-    wrote: true,
-    ruleCount: bundle.rules?.length ?? 0
+    async append(input) {
+      const row = await local.append(input);
+      try {
+        await api.cli.cursorStoreAppendRunEvents({
+          events: [
+            {
+              runId: input.runId,
+              eventType: input.eventType,
+              payload: jsonSafePayload(input.payload),
+              payloadRef: input.payloadRef ?? null,
+              idempotencyKey: input.idempotencyKey ?? `${input.runId}:${row.seq}`,
+              createdAt: row.createdAt
+            }
+          ]
+        });
+      } catch (err) {
+        console.warn(
+          `[apm] runEvents \u53EF\u89C6\u5316\u540C\u6B65\u8DF3\u8FC7 runId=${input.runId} seq=${row.seq}:`,
+          err instanceof Error ? err.message : err
+        );
+      }
+      return row;
+    },
+    list: (input) => local.list(input),
+    async delete(input) {
+      await local.delete(input);
+      const runIds = input.filter.runIds?.map((id) => id.trim()).filter(Boolean);
+      if (!runIds?.length) return;
+      try {
+        await api.cli.cursorStoreDeleteRunEvents({ runIds });
+      } catch (err) {
+        console.warn(
+          `[apm] runEvents \u53EF\u89C6\u5316\u6E05\u7406\u8DF3\u8FC7:`,
+          err instanceof Error ? err.message : err
+        );
+      }
+    }
   };
 }
-
-// src/commands/init.ts
-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\u6309 WebIDE \u81EA\u52A8\u521D\u59CB\u5316\u2026`
-  );
-  await ensureWorkspaceApmDirForInit(workdir);
-  console.log(`[apm] \u5DF2\u521B\u5EFA\u5DE5\u4F5C\u533A\u76EE\u5F55\uFF1A${workspaceApmDir(workdir)}`);
-  return { didInit: true };
-}
-
-// src/utils/project-documents.ts
-import {
-  existsSync as existsSync6,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync5,
-  rmSync,
-  writeFileSync as writeFileSync4
-} from "fs";
-import { createHash as createHash2 } from "crypto";
-import { dirname as dirname2, join as join5, relative as relative4, sep } from "path";
-var MANIFEST_FILE = "manifest.json";
-function normalizeProjectIdForPath(projectId) {
-  const id = projectId.trim();
-  if (!id) {
-    throw new Error("projectId \u4E0D\u80FD\u4E3A\u7A7A");
-  }
-  if (id.includes("..") || id.includes("/") || id.includes("\\") || id.includes("\0")) {
-    throw new Error(`\u975E\u6CD5 projectId: ${projectId}`);
-  }
-  return id;
-}
-function projectDocumentsDir(apmRoot, projectId) {
-  const id = normalizeProjectIdForPath(projectId);
-  return join5(apmRoot ?? workspaceApmDir(), "project", id);
-}
-function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
-  const normalized = normalizeLocalDocumentPath(documentPath);
-  return join5(
-    projectDocumentsDir(apmRoot, projectId),
-    ...normalized.split("/")
-  );
-}
-function normalizeLocalDocumentPath(path3) {
-  const trimmed = path3.trim().replace(/\\/g, "/");
-  if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path3}`);
-  }
-  const segments = trimmed.split("/").filter(Boolean);
-  if (segments.some((segment) => segment === ".." || segment === ".")) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path3}`);
-  }
-  return segments.join("/");
-}
-function hashLocalFileContent(content) {
-  return createHash2("sha256").update(content, "utf8").digest("hex");
-}
-function readLocalManifest(apmRoot, projectId) {
-  const manifestPath2 = join5(
-    projectDocumentsDir(apmRoot, projectId),
-    MANIFEST_FILE
-  );
-  if (!existsSync6(manifestPath2)) {
-    return null;
-  }
-  try {
-    return JSON.parse(
-      readFileSync5(manifestPath2, "utf8")
-    );
-  } catch {
-    return null;
-  }
+async function createApmCursorAgentStore(cfg2, workspaceRef) {
+  const cwd = workspaceRef.trim();
+  const [sqlite, remote] = await Promise.all([
+    openSqliteLocalAgentStore(cwd),
+    Promise.resolve(createRemoteLocalAgentStore(cfg2))
+  ]);
+  return composeLocalAgentStore({
+    agents: remote.agents,
+    runs: remote.runs,
+    checkpoints: sqlite.checkpoints,
+    runEvents: mirrorRunEventsForVisualization(cfg2, sqlite.runEvents)
+  });
 }
-function listLocalDocumentPaths(apmRoot, projectId) {
-  const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync6(root)) {
-    return [];
-  }
-  const paths = [];
-  const walk = (dir) => {
-    for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-      const abs = join5(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(abs);
-        continue;
-      }
-      if (entry.isFile() && entry.name === MANIFEST_FILE) {
-        continue;
-      }
-      const rel = relative4(root, abs).split(sep).join("/");
-      paths.push(rel);
-    }
-  };
-  walk(root);
-  return paths.sort();
+
+// src/commands/connect/core/worker/run-steer.ts
+var impl = null;
+var pending = null;
+function bindRunSteer(fn) {
+  impl = fn;
+  if (!pending) return;
+  const text = pending;
+  pending = null;
+  void fn(text);
 }
-function diffManifestPaths(remote, local) {
-  const remoteMap = new Map(
-    (remote?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
-  );
-  const localMap = new Map(
-    (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
-  );
-  const download = [];
-  for (const [path3, hash] of remoteMap) {
-    if (localMap.get(path3) !== hash) {
-      download.push(path3);
-    }
-  }
-  const deleteLocal = [];
-  for (const path3 of localMap.keys()) {
-    if (!remoteMap.has(path3)) {
-      deleteLocal.push(path3);
-    }
+function clearRunSteer() {
+  impl = null;
+  pending = null;
+}
+function deliverRunSteer(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return;
+  if (impl) {
+    void impl(trimmed);
+    return;
   }
-  return { download, deleteLocal };
+  pending = trimmed;
 }
-async function resolveProjectIdForSync(api, workdirPath, options) {
-  const explicit = options?.projectId?.trim();
-  if (explicit) {
-    return { projectId: explicit, diagnostic: null };
+
+// src/commands/connect/cursor-agent.ts
+var noopRemoteLogSync = {
+  schedule(_session) {
+  },
+  async flush(_session) {
   }
-  try {
-    const gitRoot = await resolveGitRepoRoot(workdirPath);
-    const current = await getCurrentBranch(gitRoot);
-    const taskId = taskIdFromFeatureBranch(current);
-    if (!taskId) {
-      return {
-        projectId: null,
-        diagnostic: `\u5F53\u524D\u5206\u652F ${current} \u4E0D\u662F feat/task-*\uFF0C\u65E0\u6CD5\u89E3\u6790\u6240\u5C5E\u9879\u76EE\u3002
-\u8BF7\u5728\u7279\u6027\u5206\u652F\u4E0A\u6267\u884C\uFF0C\u6216\u663E\u5F0F\u6307\u5B9A projectId\u3002`
-      };
-    }
-    const baseline = await api.cli.projectBaseBranch({ taskId });
-    const projectId = baseline.projectId?.trim() || null;
-    if (!projectId) {
-      return {
-        projectId: null,
-        diagnostic: `\u4EFB\u52A1 ${taskId} \u672A\u5173\u8054\u9879\u76EE\uFF0C\u65E0\u6CD5\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002`
-      };
-    }
-    return { projectId, diagnostic: null };
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    return {
-      projectId: null,
-      diagnostic: detail.replace(/^\[apm\]\s*/, "")
-    };
+};
+function formatCursorRunFailure(runId, options) {
+  const details = [
+    options?.statusError?.trim(),
+    options?.resultText?.trim()
+  ].filter((value, index, arr) => {
+    if (!value) return false;
+    return arr.indexOf(value) === index;
+  });
+  if (details.length === 0) {
+    return `Cursor run \u5931\u8D25: ${runId}`;
   }
+  return `Cursor run \u5931\u8D25: ${runId} \u2014 ${details.join("\uFF1B")}`;
 }
-async function syncProjectDocumentsPull(workdirPath, apmDir, options) {
-  const empty = {
-    synced: false,
-    projectId: null,
-    downloaded: 0,
-    deleted: 0
+async function obtainAgent(ctx) {
+  const store = await createApmCursorAgentStore(ctx.cfg, ctx.cwd);
+  const agentOptions = {
+    apiKey: ctx.apiKey,
+    model: { id: ctx.model || "default" },
+    local: {
+      cwd: ctx.cwd,
+      store,
+      ...ctx.customTools ? { customTools: ctx.customTools } : {},
+      ...ctx.enableSandbox ? {
+        sandboxOptions: { enabled: true },
+        // 只加载项目级设置，避免 ~/.cursor/mcp.json 里需 OAuth/审批的 MCP 在无头沙箱被拒
+        settingSources: ["project"]
+      } : {}
+    },
+    ...ctx.mode ? { mode: ctx.mode } : {}
   };
-  const cfg2 = await tryReadApmConfig();
-  if (!cfg2 || !resolveApiKey(cfg2)) {
-    console.log(
-      "[apm] \u672A\u68C0\u6D4B\u5230\u767B\u5F55\u4FE1\u606F\uFF0C\u8DF3\u8FC7\u9879\u76EE\u6587\u6863\u540C\u6B65\u3002\n[apm] \u8BF7\u5148\u6267\u884C apm login\u3002"
-    );
-    return empty;
-  }
-  const api = createApmApiClient(cfg2);
-  const { projectId, diagnostic } = await resolveProjectIdForSync(
-    api,
-    workdirPath,
-    options
-  );
-  if (!projectId) {
-    console.log(`[apm] \u672A\u80FD\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002
-${diagnostic ?? ""}`);
-    return empty;
-  }
-  const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
-  const docsDir = projectDocumentsDir(targetApmDir, projectId);
-  await ensureDirExists(docsDir);
-  const { manifest: remoteManifest } = await api.cli.getProjectDocumentManifest(
-    { projectId }
-  );
-  if (!remoteManifest) {
-    console.log(`[apm] \u9879\u76EE ${projectId} \u65E0\u9879\u76EE\u6587\u6863 manifest\uFF0C\u8DF3\u8FC7\u540C\u6B65\u3002`);
-    return { ...empty, projectId };
-  }
-  const localManifest = readLocalManifest(targetApmDir, projectId);
-  const { download, deleteLocal } = diffManifestPaths(
-    remoteManifest,
-    localManifest
-  );
-  let downloaded = 0;
-  if (download.length > 0) {
-    const { list } = await api.cli.listProjectDocuments({
-      projectId,
-      paths: download.join(",")
-    });
-    for (const doc of list) {
-      const absPath = toFsPath(
-        projectDocumentLocalPath(targetApmDir, projectId, doc.path)
+  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}`);
+      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
       );
-      await ensureDirExists(dirname2(absPath));
-      writeFileSync4(absPath, doc.content, "utf8");
-      downloaded += 1;
-    }
-  }
-  let deleted = 0;
-  for (const path3 of deleteLocal) {
-    const absPath = toFsPath(
-      projectDocumentLocalPath(targetApmDir, projectId, path3)
-    );
-    if (existsSync6(absPath)) {
-      rmSync(absPath, { force: true });
-      deleted += 1;
-    }
-  }
-  writeFileSync4(
-    toFsPath(join5(docsDir, MANIFEST_FILE)),
-    `${JSON.stringify(remoteManifest, null, 2)}
-`,
-    "utf8"
-  );
-  console.log(
-    `[apm] \u5DF2\u540C\u6B65\u9879\u76EE\u6587\u6863: projectId=${projectId} \u4E0B\u8F7D ${downloaded}\uFF0C\u5220\u9664\u672C\u5730 ${deleted} \u2192 .apm/project/${projectId}/`
-  );
-  return {
-    synced: true,
-    projectId,
-    downloaded,
-    deleted
-  };
-}
-async function syncProjectDocumentsPush(cfg2, workdirPath, apmRoot, options) {
-  const api = createApmApiClient(cfg2);
-  const { projectId } = await resolveProjectIdForSync(
-    api,
-    workdirPath,
-    options
-  );
-  if (!projectId) {
-    return 0;
-  }
-  const targetApmDir = apmRoot ?? workspaceApmDir(workdirPath);
-  const localPaths = listLocalDocumentPaths(targetApmDir, projectId);
-  if (localPaths.length === 0) {
-    console.log("[apm] \u9879\u76EE\u6587\u6863\u65E0\u672C\u5730\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u63A8\u9001");
-    return 0;
-  }
-  const remoteManifest = (await api.cli.getProjectDocumentManifest({ projectId })).manifest ?? null;
-  const remoteHashByPath = new Map(
-    (remoteManifest?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
-  );
-  const remoteDescriptionByPath = new Map(
-    (remoteManifest?.documents ?? []).map((doc) => [doc.path, doc.description])
-  );
-  let synced = 0;
-  for (const path3 of localPaths) {
-    const absPath = toFsPath(
-      projectDocumentLocalPath(targetApmDir, projectId, path3)
-    );
-    const content = readFileSync5(absPath, "utf8");
-    const contentHash = hashLocalFileContent(content);
-    if (remoteHashByPath.get(path3) === contentHash) {
-      continue;
+      ctx.onInvalidatePersistedAgentId?.();
     }
-    await api.cli.upsertProjectDocument({
-      projectId,
-      path: path3,
-      content,
-      description: remoteDescriptionByPath.get(path3) ?? void 0
-    });
-    synced += 1;
-    console.log(`[apm] \u5DF2\u540C\u6B65\u9879\u76EE\u6587\u6863: ${path3}`);
-  }
-  if (synced === 0) {
-    console.log("[apm] \u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
   }
-  return synced;
-}
-
-// src/commands/connect/upload-package-artifact.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
-function packageTmpDir(packageId) {
-  return `/data/package-tmp/${packageId}`;
-}
-function expectedLocalArtifactPath(target, packageId) {
-  const fileName = target === "frontend" ? "dist.zip" : "jars.zip";
-  return path2.join(packageTmpDir(packageId), fileName);
-}
-function packageArtifactObjectKey(target, projectId, timestampMs = Date.now()) {
-  const folder = target === "frontend" ? "vue" : "java";
-  const suffix = target === "frontend" ? "dist.zip" : "jar.zip";
-  return `packages/${projectId}/${folder}/${timestampMs}.${suffix}`;
-}
-function removePackageTmpDir(packageId) {
-  const dir = packageTmpDir(packageId);
   try {
-    fs2.rmSync(dir, { recursive: true, force: true });
+    const agent = await Agent.create(agentOptions);
+    return { agent, resumed: false };
   } catch (err) {
-    console.warn(
-      `[apm] \u6E05\u7406\u6253\u5305\u4E34\u65F6\u76EE\u5F55\u5931\u8D25 ${dir}:`,
-      err instanceof Error ? err.message : err
-    );
+    if (ctx.enableSandbox && err instanceof Error && /sandbox/i.test(err.message)) {
+      console.warn("[apm] sandbox \u4E0D\u53EF\u7528\uFF0C\u56DE\u9000\u4E3A\u65E0 sandbox:", err.message);
+      return obtainAgent({ ...ctx, enableSandbox: false });
+    }
+    throw err;
   }
 }
-async function uploadPackageArtifact(cfg2, target, packageId, projectId) {
-  const localPath = expectedLocalArtifactPath(target, packageId);
-  if (!fs2.existsSync(localPath)) {
-    throw new Error(`\u6253\u5305\u4EA7\u7269\u4E0D\u5B58\u5728: ${localPath}`);
+async function runCursorAgent(cfg2, ctx, options) {
+  const signal = options.signal;
+  if (signal?.aborted) {
+    throw new Error("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u4EFB\u52A1\u4E2D\u65AD");
   }
-  const stat = fs2.statSync(localPath);
-  if (!stat.isFile() || stat.size <= 0) {
-    throw new Error(`\u6253\u5305\u4EA7\u7269\u65E0\u6548\u6216\u4E3A\u7A7A: ${localPath}`);
+  const apiKey = ctx.apiKey.trim();
+  if (!apiKey) {
+    throw new Error("\u7F3A\u5C11 apiKey\uFF0C\u65E0\u6CD5\u8C03\u7528 Cursor SDK");
   }
-  const objectKey = packageArtifactObjectKey(target, projectId);
-  const { client, bucket, publicEndpoint } = await createApmLogMinioClient(cfg2);
-  await client.ensureBucket(bucket);
-  await client.fPutObject(bucket, objectKey, localPath, {
-    "Content-Type": "application/zip"
-  });
-  removePackageTmpDir(packageId);
-  const base = publicEndpoint?.replace(/\/$/, "") ?? "";
-  const artifactUrl = base ? `${base}/${bucket}/${objectKey}` : null;
-  return { artifactPath: objectKey, artifactUrl };
-}
-
-// src/commands/connect/core/worker/handlers/package.ts
-async function updatePackageStatus(cfg2, packageId, status, extra) {
-  const api = createApmApiClient(cfg2);
-  await api.cli.projectPackageUpdateStatus({
-    id: packageId,
-    status,
-    ...extra?.error != null ? { error: extra.error } : {},
-    ...extra?.content != null ? { content: extra.content } : {},
-    ...extra?.artifactPath != null ? { artifactPath: extra.artifactPath } : {},
-    ...extra?.artifactUrl != null ? { artifactUrl: extra.artifactUrl } : {}
+  const workdir = resolveWorkdirPath(ctx.workdir);
+  const customTools = createCursorCustomTools(cfg2, {
+    onAskQuestion: options.onAskQuestion,
+    appendMessageContent: options.appendMessageContent,
+    enableAppendMessage: options.enableAppendMessage,
+    enableAskQuestion: options.enableAskQuestion,
+    askQuestionExecute: options.askQuestionExecute,
+    enableWebIdePlanTools: options.enableWebIdePlanTools,
+    enableMysqlTools: options.enableMysqlTools,
+    sqlExecutionId: options.sqlExecutionId,
+    toolNames: options.toolNames,
+    taskId: options.taskId,
+    workdir
   });
-}
-async function handleWebIdePackage(cfg2, msg2, signal) {
-  const workdir = requireRemoteWorkdir(msg2.workdir);
-  const messageId = msg2.messageId;
-  const packageId = msg2.packageId;
-  const projectId = msg2.projectId;
+  const enableSandbox = Boolean(options.enableSandbox);
+  let prompt = withPlanModeToolHint(ctx.prompt, ctx.mode);
+  prompt = withWorkspaceBoundaryHint(prompt);
   console.log(
-    `[apm] webide-package target=${msg2.target} packageId=${packageId} projectId=${projectId} baseBranch=${msg2.baseBranch}`
+    `[apm] Cursor Agent \u5F00\u59CB messageId=${ctx.messageId} cwd=${workdir} sandbox=${enableSandbox}`
   );
-  await updatePackageStatus(cfg2, packageId, "RUNNING");
-  const eventSession = new EventSession(msg2.content);
-  const logSyncRef = {
-    current: createThrottledWebIdeMessageLogSync(
-      cfg2,
-      {
-        taskId: `package:${packageId}`,
-        messageId,
-        agentId: "webide-package"
-      },
-      (err) => {
-        console.warn(
-          "[apm] WebIDE \u6253\u5305\u65E5\u5FD7\u540C\u6B65\u5931\u8D25:",
-          err instanceof Error ? err.message : err
-        );
-      },
-      {
-        objectPrefixOverride: `events/webide-package/${packageId}/`
-      }
-    )
-  };
-  const syncPrepLog = async () => {
-    const sync = logSyncRef.current;
-    if (!sync) return;
-    sync.schedule(eventSession);
-    await sync.flush(eventSession);
-  };
-  const runPrepStep = async (step, work, formatOk) => {
-    eventSession.addCliStep(step, "\u8FDB\u884C\u4E2D\u2026", "running");
-    await syncPrepLog();
-    try {
-      const result = await work();
-      eventSession.addCliStep(step, formatOk(result), "ok");
-      await syncPrepLog();
-      return result;
-    } catch (err) {
-      const detail = err instanceof Error ? err.message : String(err);
-      eventSession.addCliStep(step, detail, "error");
-      await syncPrepLog();
-      throw err;
-    }
-  };
-  try {
-    if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
-    await runPrepStep(
-      "\u521D\u59CB\u5316\u5DE5\u4F5C\u533A",
-      async () => {
-        const { didInit } = await ensureWorkspaceInitialized(workdir);
-        return didInit;
-      },
-      (didInit) => didInit ? "\u5DF2\u521D\u59CB\u5316\u5DE5\u4F5C\u533A" : "\u5DE5\u4F5C\u533A\u5DF2\u5C31\u7EEA"
-    );
-    if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
-    await runPrepStep(
-      "\u540C\u6B65 WebIDE \u89C4\u5219",
-      async () => syncWebIdeAgentFiles(workdir, cfg2),
-      (result) => result.wrote ? `\u5DF2\u5199\u5165 ${result.ruleCount} \u6761\u89C4\u5219` : "\u89C4\u5219\u672A\u53D8\u5316\uFF0C\u8DF3\u8FC7"
-    );
-    await runPrepStep(
-      "\u5DE5\u4F5C\u533A\u4ED3\u5E93\u6E05\u5355",
-      async () => {
-        const workspaceRepos = resolveWorkspaceRepos(workdir);
-        try {
-          await enrichWorkspaceReposRemoteUrls(workspaceRepos);
-        } catch (err) {
-          console.warn(
-            "[apm] \u8865\u9F50 workspace-repos remoteUrl \u5931\u8D25:",
-            err instanceof Error ? err.message : err
-          );
-        }
-        return workspaceRepos;
-      },
-      (repos) => `kind=${repos.kind} repos=${repos.repos.length}`
-    );
-    if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
-    await runPrepStep(
-      "\u5207\u6362\u57FA\u7EBF\u5E76\u62C9\u53D6\u6700\u65B0",
-      async () => checkoutBaselineBranches(msg2.baseBranch, { cwd: workdir }),
-      (result) => `baseline=${result.baseline} kind=${result.kind} repos=${result.repos.length}`
-    );
-    if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
-    await runPrepStep(
-      "\u540C\u6B65\u9879\u76EE\u6587\u6863",
-      async () => {
-        const docs = await syncProjectDocumentsPull(workdir, void 0, {
-          projectId
-        });
-        return docs;
-      },
-      (result) => {
-        if (!result.synced) {
-          return result.projectId ? "\u65E0\u9700\u540C\u6B65\u6216\u8DF3\u8FC7" : "\u8DF3\u8FC7\uFF1A\u65E0 projectId";
-        }
-        return `downloaded=${result.downloaded} deleted=${result.deleted}`;
+  const { agent, resumed } = await obtainAgent({
+    cfg: cfg2,
+    apiKey,
+    model: ctx.model,
+    cwd: workdir,
+    user: ctx.user,
+    mode: ctx.mode,
+    resumeAgentId: ctx.resumeAgentId,
+    customTools,
+    enableSandbox,
+    onInvalidatePersistedAgentId: options.onInvalidatePersistedAgentId
+  });
+  const invalidateAgentMapping = () => {
+    options.onInvalidatePersistedAgentId?.();
+  };
+  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;
+    void activeRun.cancel().catch(() => void 0);
+  };
+  signal?.addEventListener("abort", abortRun, { once: true });
+  try {
+    const run = await agent.send(prompt, {
+      ...ctx.mode ? { mode: ctx.mode } : {},
+      local: {
+        ...options.forceSend ? { force: true } : {},
+        customTools
       }
-    );
-    eventSession.addCliStep("\u542F\u52A8\u6253\u5305 Agent", "\u51C6\u5907 create\u2026", "running");
-    await syncPrepLog();
-    let failedByTool = false;
-    const outcome = await runCursorAgent(
-      cfg2,
-      {
-        messageId,
-        prompt: msg2.content,
-        model: msg2.model,
-        apiKey: msg2.apiKey,
-        workdir,
-        user: msg2.user || "webide"
-      },
-      {
-        signal,
-        forceSend: true,
-        eventSession,
-        enableAppendMessage: false,
-        enableAskQuestion: false,
-        enableWebIdePlanTools: false,
-        enablePtySessionMcp: false,
-        enableSandbox: false,
-        enablePackageStatusTools: true,
-        packageId,
-        projectId,
-        onPackageFailed: async () => {
-          failedByTool = true;
-        },
-        taskId: `package:${packageId}`,
-        createRemoteLogSync: (agentId) => {
-          logSyncRef.current = createThrottledWebIdeMessageLogSync(
-            cfg2,
-            {
-              taskId: `package:${packageId}`,
-              messageId,
-              agentId
-            },
-            (err) => {
-              console.warn(
-                "[apm] WebIDE \u6253\u5305\u65E5\u5FD7\u540C\u6B65\u5931\u8D25:",
-                err instanceof Error ? err.message : err
-              );
-            },
-            {
-              objectPrefixOverride: `events/webide-package/${packageId}/`
-            }
-          );
-          return logSyncRef.current;
-        },
-        onRunStarted: async ({ agentId, runId }) => {
-          eventSession.addCliStep(
-            "\u542F\u52A8\u6253\u5305 Agent",
-            `agentId=${agentId} runId=${runId}`,
-            "ok"
+    });
+    activeRun = run;
+    console.log(`[apm] Cursor run id=${run.id} agentId=${agent.agentId}`);
+    bindRunSteer(async (text) => {
+      const steer = run.steer;
+      if (!steer) {
+        console.warn(`[apm] \u5F53\u524D run \u4E0D\u652F\u6301 steer runId=${run.id}`);
+        return;
+      }
+      try {
+        const outcome = await steer(text);
+        console.log(`[apm] steer outcome=${outcome} runId=${run.id}`);
+      } catch (err) {
+        console.error(
+          `[apm] steer \u5931\u8D25 runId=${run.id}:`,
+          err instanceof Error ? err.message : err
+        );
+      }
+    });
+    await options.onRunStarted?.({ agentId: agent.agentId, runId: run.id });
+    let lastRunErrorStatus;
+    for await (const event of run.stream()) {
+      if (signal?.aborted) {
+        abortRun();
+        throw new Error("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u4EFB\u52A1\u4E2D\u65AD");
+      }
+      if (event.type === "status" && event.status === "ERROR") {
+        const message = event.message?.trim();
+        if (message) {
+          lastRunErrorStatus = message;
+          console.error(
+            `[apm] Cursor run status=ERROR runId=${run.id}: ${message}`
           );
-          logSyncRef.current?.schedule(eventSession);
-          await logSyncRef.current?.markRun(runId, "running");
-          await logSyncRef.current?.flush(eventSession);
         }
       }
-    );
-    const tokenUsage = outcome.usage != null ? {
-      modelId: outcome.modelId ?? (msg2.model?.trim() || void 0),
-      inputTokens: outcome.usage.inputTokens,
-      outputTokens: outcome.usage.outputTokens,
-      cacheReadTokens: outcome.usage.cacheReadTokens,
-      cacheWriteTokens: outcome.usage.cacheWriteTokens,
-      totalTokens: outcome.usage.totalTokens,
-      ...outcome.usage.reasoningTokens != null ? { reasoningTokens: outcome.usage.reasoningTokens } : {}
-    } : void 0;
-    if (outcome.status === "error") {
-      const detail = formatCursorRunFailure(outcome.runId, {
-        resultText: outcome.result
+      options.onStreamEvent?.(event);
+      eventSession.addEvent(event);
+      syncRemoteLog.schedule(eventSession);
+    }
+    await syncRemoteLog.flush(eventSession);
+    const result = await run.wait();
+    if (result.usage) {
+      eventSession.addRunUsage(result.usage, {
+        durationMs: result.durationMs
       });
-      await logSyncRef.current?.markRun(
-        outcome.runId,
-        "error",
-        detail,
-        tokenUsage
+      await syncRemoteLog.flush(eventSession);
+      console.log(
+        `[apm] Cursor usage total=${result.usage.totalTokens} in=${result.usage.inputTokens} out=${result.usage.outputTokens} cache=${result.usage.cacheReadTokens}/${result.usage.cacheWriteTokens}`
       );
-      if (!failedByTool) {
-        await updatePackageStatus(cfg2, packageId, "FAILED", { error: detail });
-      }
-      return;
     }
-    if (outcome.status === "cancelled" || signal.aborted) {
-      await logSyncRef.current?.markRun(
-        outcome.runId,
-        "cancelled",
-        "\u5DF2\u53D6\u6D88",
-        tokenUsage
-      );
-      await updatePackageStatus(cfg2, packageId, "CANCELLED", {
-        error: "\u5DF2\u53D6\u6D88"
+    if (result.status === "error") {
+      const failureMessage = formatCursorRunFailure(result.id, {
+        statusError: lastRunErrorStatus,
+        resultText: result.result
       });
-      return;
+      console.error(`[apm] ${failureMessage}`);
+      if (resumed) {
+        invalidateAgentMapping();
+      }
+      throw new Error(failureMessage);
     }
-    await logSyncRef.current?.markRun(
-      outcome.runId,
-      "finished",
-      null,
-      tokenUsage
-    );
-    if (failedByTool) {
-      console.log(
-        `[apm] webide-package Agent \u5DF2\u6807 FAILED packageId=${packageId}`
-      );
-      return;
+    if (result.status === "cancelled") {
+      throw new Error(`Cursor run \u5DF2\u53D6\u6D88: ${result.id}`);
     }
-    const uploaded = await runPrepStep(
-      "\u4E0A\u4F20\u6253\u5305\u4EA7\u7269\u5230 MinIO",
-      () => uploadPackageArtifact(cfg2, msg2.target, packageId, projectId),
-      (result) => `objectKey=${result.artifactPath}${result.artifactUrl ? ` url=${result.artifactUrl}` : ""}`
-    );
-    await updatePackageStatus(cfg2, packageId, "SUCCESS", {
-      artifactPath: uploaded.artifactPath,
-      ...uploaded.artifactUrl ? { artifactUrl: uploaded.artifactUrl } : {}
-    });
-    console.log(
-      `[apm] webide-package \u5B8C\u6210 target=${msg2.target} packageId=${packageId} agentId=${outcome.agentId} artifact=${uploaded.artifactPath}`
-    );
+    console.log(`[apm] Cursor Agent \u5B8C\u6210 messageId=${ctx.messageId}`);
+    const artifacts = await agent.listArtifacts().catch(() => []);
+    const artifactDocuments = [];
+    for (const artifact of artifacts) {
+      try {
+        const content = (await agent.downloadArtifact(artifact.path)).toString(
+          "utf8"
+        );
+        artifactDocuments.push({ path: artifact.path, content });
+      } catch (err) {
+        console.warn(
+          `[apm] \u8BFB\u53D6\u4EA7\u7269\u5931\u8D25 path=${artifact.path}:`,
+          err instanceof Error ? err.message : err
+        );
+      }
+    }
+    return {
+      runId: result.id,
+      agentId: agent.agentId,
+      status: result.status,
+      result: result.result,
+      durationMs: result.durationMs,
+      usage: result.usage,
+      modelId: result.model?.id?.trim() || ctx.model?.trim() || void 0,
+      assistantText: eventSession.getAssistantText(),
+      createPlan: eventSession.getCreatePlanContent(),
+      artifacts,
+      artifactDocuments
+    };
   } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    console.error(`[apm] webide-package \u5931\u8D25: ${detail}`);
-    try {
-      if (signal.aborted) {
-        await updatePackageStatus(cfg2, packageId, "CANCELLED", {
-          error: detail
-        });
-      } else {
-        await updatePackageStatus(cfg2, packageId, "FAILED", { error: detail });
+    if (err instanceof CursorAgentError) {
+      if (resumed) {
+        invalidateAgentMapping();
       }
-    } catch (statusErr) {
-      console.error(
-        "[apm] \u5199\u5165\u6253\u5305 FAILED \u5931\u8D25:",
-        statusErr instanceof Error ? statusErr.message : statusErr
+      throw new Error(
+        `Cursor \u542F\u52A8\u5931\u8D25: ${err.message}${err.isRetryable ? "\uFF08\u53EF\u91CD\u8BD5\uFF09" : ""}`
       );
     }
+    throw err;
+  } finally {
+    clearRunSteer();
+    signal?.removeEventListener("abort", abortRun);
+    await agent[Symbol.asyncDispose]();
+  }
+}
+
+// src/commands/connect/webide-agent-registry.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, resolve as resolve6 } from "node:path";
+function registryPath(workdir, taskId, fileName = "cursor-agent.json") {
+  return resolve6(workdir, ".apm", "webide", taskId, fileName);
+}
+var DESIGN_AGENT_FILE = "design-agent.json";
+function readRegistry(path) {
+  if (!existsSync5(path)) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const raw = parsed;
+      const state = {};
+      if (typeof raw.agentId === "string" && raw.agentId.trim()) {
+        state.agentId = raw.agentId.trim();
+      }
+      if (typeof raw.taskId === "string" && raw.taskId.trim()) {
+        state.taskId = raw.taskId.trim();
+      }
+      if (typeof raw.messageId === "string" && raw.messageId.trim()) {
+        state.messageId = raw.messageId.trim();
+      }
+      if (typeof raw.action === "string" && raw.action.trim()) {
+        state.action = raw.action.trim();
+      }
+      if (raw.status === "TYPING" || raw.status === "SUCCESS" || raw.status === "FAILED" || raw.status === "CANCELLED") {
+        state.status = raw.status;
+      }
+      if (typeof raw.updatedAt === "string" && raw.updatedAt.trim()) {
+        state.updatedAt = raw.updatedAt.trim();
+      }
+      return state;
+    }
+  } catch {
+  }
+  return {};
+}
+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 = registryPath(workdir, trimmedTaskId);
+  const current = readRegistry(path);
+  const next = {
+    ...current,
+    taskId: trimmedTaskId,
+    updatedAt: patch.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (patch.agentId !== void 0) {
+    const agentId = patch.agentId.trim();
+    if (agentId) next.agentId = agentId;
+    else delete next.agentId;
+  }
+  if (patch.messageId !== void 0) {
+    const messageId = patch.messageId.trim();
+    if (messageId) next.messageId = messageId;
+    else delete next.messageId;
+  }
+  if (patch.action !== void 0) {
+    const action = patch.action.trim();
+    if (action) next.action = action;
+    else delete next.action;
+  }
+  if (patch.status !== void 0) {
+    next.status = patch.status;
   }
+  writeRegistry(path, next);
+}
+function loadWebIdeAgentId(workdir, taskId) {
+  return readRegistry(registryPath(workdir, taskId)).agentId;
+}
+function saveWebIdeAgentId(workdir, taskId, agentId) {
+  syncWebIdeTaskState(workdir, taskId, { agentId });
+}
+function clearWebIdeAgentId(workdir, taskId) {
+  const path = registryPath(workdir, taskId);
+  if (!existsSync5(path)) return;
+  syncWebIdeTaskState(workdir, taskId, { agentId: "" });
+}
+function loadWebIdeDesignAgentId(workdir, taskId) {
+  return readRegistry(registryPath(workdir, taskId, DESIGN_AGENT_FILE)).agentId;
+}
+function saveWebIdeDesignAgentId(workdir, taskId, agentId) {
+  const trimmedTaskId = taskId.trim();
+  if (!trimmedTaskId) return;
+  const path = registryPath(workdir, trimmedTaskId, DESIGN_AGENT_FILE);
+  const current = readRegistry(path);
+  writeRegistry(path, {
+    ...current,
+    taskId: trimmedTaskId,
+    agentId: agentId.trim() || void 0,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function clearWebIdeDesignAgentId(workdir, taskId) {
+  const path = registryPath(workdir, taskId, DESIGN_AGENT_FILE);
+  if (!existsSync5(path)) return;
+  const current = readRegistry(path);
+  const next = { ...current };
+  delete next.agentId;
+  writeRegistry(path, {
+    ...next,
+    taskId: taskId.trim(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
 }
 
-// src/commands/connect/ensure-message-reply.ts
-var DEFAULT_REPLY = "\u4EFB\u52A1\u5DF2\u5B8C\u6210\u3002";
-function resolveMessageReplyFallback(fallback) {
-  for (const candidate of [
-    fallback.assistantText,
-    fallback.result,
-    fallback.createPlan
-  ]) {
-    const trimmed = candidate?.trim();
-    if (trimmed) {
-      return trimmed;
+// src/commands/connect/webide-ask-question.ts
+function asString4(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function parseQuestions(args) {
+  const title = asString4(args.title) || void 0;
+  const raw = args.questions;
+  if (!Array.isArray(raw) || raw.length === 0) {
+    throw new Error("AskQuestion \u7F3A\u5C11 questions");
+  }
+  const questions = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const row = item;
+    const id = asString4(row.id);
+    const prompt = asString4(row.prompt);
+    const optionsRaw = row.options;
+    if (!id || !prompt || !Array.isArray(optionsRaw)) continue;
+    const options = [];
+    for (const opt of optionsRaw) {
+      if (!opt || typeof opt !== "object" || Array.isArray(opt)) continue;
+      const o = opt;
+      const oid = asString4(o.id);
+      const label = asString4(o.label);
+      if (oid && label) options.push({ id: oid, label });
+    }
+    if (options.length < 2) {
+      throw new Error(`AskQuestion \u95EE\u9898 ${id} \u81F3\u5C11\u9700\u8981 2 \u4E2A\u9009\u9879`);
     }
+    questions.push({ id, prompt, options });
   }
-  return DEFAULT_REPLY;
-}
-
-// src/commands/connect/core/worker/handlers/start-project.ts
-async function updateStatus(cfg2, messageId, status) {
-  const api = createApmApiClient(cfg2);
-  await api.cli.webideUpdateMessageStatus({ id: messageId, status });
+  if (questions.length === 0) {
+    throw new Error("AskQuestion \u65E0\u6709\u6548\u95EE\u9898");
+  }
+  return { title, questions };
 }
-async function setError(cfg2, messageId, error) {
+async function fetchAssumptionAnswersAndContinueAssessment(options) {
+  const { cfg: cfg2, taskId, questionIds, title } = options;
   const api = createApmApiClient(cfg2);
-  await api.cli.webideSetMessageError({ id: messageId, error });
-}
-async function handleStartProject(cfg2, msg2, signal) {
-  const workdir = requireRemoteWorkdir(msg2.workdir);
-  const messageId = msg2.messageId;
-  const taskId = msg2.taskId;
+  const list = await api.cli.webideListAssumptions({ taskId });
+  const byId = new Map(list.assumptions.map((a) => [a.questionId, a]));
+  const ids = questionIds && questionIds.length > 0 ? questionIds : list.assumptions.filter((a) => a.status === "RESOLVED").map((a) => a.questionId);
+  if (ids.length === 0) {
+    throw new Error("\u6CA1\u6709\u5DF2\u786E\u8BA4\u7684\u5047\u8BBE");
+  }
+  const answers = [];
+  for (const id of ids) {
+    const row = byId.get(id);
+    if (!row || row.status !== "RESOLVED") {
+      throw new Error(`\u5047\u8BBE\u5C1A\u672A\u5168\u90E8\u786E\u8BA4: ${id}`);
+    }
+    answers.push({
+      questionId: id,
+      prompt: row.prompt,
+      selectedOptionId: row.selectedOptionId,
+      customAnswer: row.customAnswer,
+      resolution: row.resolution
+    });
+  }
   console.log(
-    `[apm] webide-start-project target=${msg2.target} restart=${msg2.restart} taskId=${taskId} messageId=${messageId}`
+    `[apm] \u5047\u8BBE\u7ED3\u679C\u5DF2\u62C9\u53D6 taskId=${taskId} count=${answers.length}`
   );
-  await updateStatus(cfg2, messageId, "TYPING");
-  const eventSession = new EventSession(msg2.content);
-  const logSyncRef = {
-    current: createThrottledWebIdeMessageLogSync(
-      cfg2,
-      { taskId, messageId, agentId: "webide-start-project" },
-      (err) => {
-        console.warn(
-          "[apm] WebIDE \u542F\u52A8\u9879\u76EE\u65E5\u5FD7\u540C\u6B65\u5931\u8D25:",
-          err instanceof Error ? err.message : err
-        );
-      }
-    )
-  };
-  try {
-    if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
-    await ensureWorkspaceInitialized(workdir);
-    await syncWebIdeAgentFiles(workdir, cfg2);
+  return JSON.stringify({ title, answers }, null, 2);
+}
+function createWebIdeAskQuestionExecute(options) {
+  const { cfg: cfg2, taskId, onAwaitingAssumptions } = options;
+  return async (args) => {
+    const parsed = parseQuestions(args);
     const api = createApmApiClient(cfg2);
-    const outcome = await runCursorAgent(
-      cfg2,
-      {
-        messageId,
-        prompt: msg2.content,
-        model: msg2.model,
-        apiKey: msg2.apiKey,
-        workdir,
-        user: msg2.user || "webide"
-      },
-      {
-        signal,
-        forceSend: true,
-        eventSession,
-        enableAppendMessage: false,
-        enableAskQuestion: false,
-        enableWebIdePlanTools: false,
-        enablePtySessionMcp: true,
-        enableSandbox: false,
-        taskId,
-        createRemoteLogSync: (agentId) => {
-          logSyncRef.current = createThrottledWebIdeMessageLogSync(
-            cfg2,
-            { taskId, messageId, agentId },
-            (err) => {
-              console.warn(
-                "[apm] WebIDE \u542F\u52A8\u9879\u76EE\u65E5\u5FD7\u540C\u6B65\u5931\u8D25:",
-                err instanceof Error ? err.message : err
-              );
-            }
-          );
-          return logSyncRef.current;
-        },
-        onRunStarted: async ({ agentId, runId }) => {
-          eventSession.addCliStep(
-            "\u542F\u52A8\u72EC\u7ACB Agent",
-            `agentId=${agentId} runId=${runId}`,
-            "ok"
-          );
-          logSyncRef.current?.schedule(eventSession);
-          await logSyncRef.current?.markRun(runId, "running");
-          await logSyncRef.current?.flush(eventSession);
-        }
-      }
+    console.log(
+      `[apm] AskQuestion \u521B\u5EFA\u5F85\u786E\u8BA4\u9879 taskId=${taskId} count=${parsed.questions.length}`
     );
-    const tokenUsage = outcome.usage != null ? {
-      modelId: outcome.modelId ?? (msg2.model?.trim() || void 0),
-      inputTokens: outcome.usage.inputTokens,
-      outputTokens: outcome.usage.outputTokens,
-      cacheReadTokens: outcome.usage.cacheReadTokens,
-      cacheWriteTokens: outcome.usage.cacheWriteTokens,
-      totalTokens: outcome.usage.totalTokens,
-      ...outcome.usage.reasoningTokens != null ? { reasoningTokens: outcome.usage.reasoningTokens } : {}
-    } : void 0;
-    if (outcome.status === "error") {
-      const detail = formatCursorRunFailure(outcome.runId, {
-        resultText: outcome.result
-      });
-      await logSyncRef.current?.markRun(
-        outcome.runId,
-        "error",
-        detail,
-        tokenUsage
-      );
-      await setError(cfg2, messageId, detail);
-      return;
-    }
-    if (outcome.status === "cancelled" || signal.aborted) {
-      await logSyncRef.current?.markRun(
-        outcome.runId,
-        "cancelled",
-        "\u5DF2\u53D6\u6D88",
-        tokenUsage
-      );
-      await updateStatus(cfg2, messageId, "CANCELLED");
-      return;
-    }
-    const fallback = resolveMessageReplyFallback({
-      assistantText: outcome.assistantText,
-      result: outcome.result
+    await api.cli.webideReplaceAssumptions({
+      taskId,
+      title: parsed.title,
+      questions: parsed.questions
     });
-    await api.cli.webideEnsureMessageContent({
-      id: messageId,
-      content: fallback
+    await api.cli.webideRunAction({
+      taskId,
+      action: "await-assumptions"
     });
-    await logSyncRef.current?.markRun(
-      outcome.runId,
-      "finished",
-      null,
-      tokenUsage
-    );
-    await updateStatus(cfg2, messageId, "SUCCESS");
-    console.log(
-      `[apm] webide-start-project \u5B8C\u6210 target=${msg2.target} messageId=${messageId} agentId=${outcome.agentId}`
-    );
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    console.error(`[apm] webide-start-project \u5931\u8D25: ${detail}`);
-    try {
-      await setError(cfg2, messageId, detail);
-    } catch (statusErr) {
-      console.error(
-        "[apm] \u5199\u5165\u542F\u52A8\u9879\u76EE FAILED \u5931\u8D25:",
-        statusErr instanceof Error ? statusErr.message : statusErr
-      );
+    onAwaitingAssumptions?.();
+    return [
+      "\u5047\u8BBE\u5DF2\u63D0\u4EA4\uFF0C\u5DE5\u4F5C\u6D41\u8FDB\u5165\u300C\u5F85\u786E\u8BA4\u5047\u8BBE\u300D\u3002",
+      "\u672C\u8F6E\u5FC5\u987B\u7ACB\u5373\u7ED3\u675F\uFF1A\u4E0D\u8981\u7EE7\u7EED\u8BC4\u4F30\uFF0C\u4E0D\u8981\u8C03\u7528 RecommendPlan\uFF0C\u4E0D\u8981\u518D\u6B21\u8C03\u7528 AskQuestion\u3002",
+      "\u7528\u6237\u786E\u8BA4\u540E\uFF0C\u4E0B\u4E00\u8F6E\u4F1A\u5E26\u4E0A\u7B54\u6848\u5E76\u7EE7\u7EED\u8BC4\u4F30\u3002"
+    ].join("");
+  };
+}
+
+// src/utils/minio.ts
+import * as Minio from "minio";
+var MinioClient = class {
+  inner;
+  constructor(opts) {
+    const endPoint = opts.endPoint.replace(/^https?:\/\//i, "").split("/")[0] ?? opts.endPoint;
+    this.inner = new Minio.Client({
+      endPoint,
+      port: opts.port,
+      useSSL: opts.useSSL,
+      accessKey: opts.accessKey,
+      secretKey: opts.secretKey
+    });
+  }
+  async ensureBucket(bucket) {
+    const exists = await this.inner.bucketExists(bucket);
+    if (!exists) {
+      await this.inner.makeBucket(bucket);
     }
   }
-}
-
-// src/commands/connect/webide-agent-registry.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname3, resolve as resolve6 } from "node:path";
-function registryPath(workdir, taskId, fileName = "cursor-agent.json") {
-  return resolve6(workdir, ".apm", "webide", taskId, fileName);
-}
-var DESIGN_AGENT_FILE = "design-agent.json";
-function readRegistry(path3) {
-  if (!existsSync7(path3)) {
-    return {};
+  async putObject(bucket, objectKey, body, meta) {
+    await this.inner.putObject(bucket, objectKey, body, body.length, meta);
   }
-  try {
-    const parsed = JSON.parse(readFileSync6(path3, "utf8"));
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const raw = parsed;
-      const state = {};
-      if (typeof raw.agentId === "string" && raw.agentId.trim()) {
-        state.agentId = raw.agentId.trim();
-      }
-      if (typeof raw.taskId === "string" && raw.taskId.trim()) {
-        state.taskId = raw.taskId.trim();
-      }
-      if (typeof raw.messageId === "string" && raw.messageId.trim()) {
-        state.messageId = raw.messageId.trim();
-      }
-      if (typeof raw.action === "string" && raw.action.trim()) {
-        state.action = raw.action.trim();
-      }
-      if (raw.status === "TYPING" || raw.status === "SUCCESS" || raw.status === "FAILED" || raw.status === "CANCELLED") {
-        state.status = raw.status;
-      }
-      if (typeof raw.updatedAt === "string" && raw.updatedAt.trim()) {
-        state.updatedAt = raw.updatedAt.trim();
-      }
-      return state;
-    }
-  } catch {
+  /** 大文件：从本地路径流式上传，避免整包读入内存 */
+  async fPutObject(bucket, objectKey, filePath, meta) {
+    await this.inner.fPutObject(bucket, objectKey, filePath, meta);
   }
-  return {};
-}
-function writeRegistry(path3, registry) {
-  mkdirSync5(dirname3(path3), { recursive: true });
-  writeFileSync5(path3, `${JSON.stringify(registry, null, 2)}
-`, "utf8");
-}
-function syncWebIdeTaskState(workdir, taskId, patch) {
-  const trimmedTaskId = taskId.trim();
-  if (!trimmedTaskId) return;
-  const path3 = registryPath(workdir, trimmedTaskId);
-  const current = readRegistry(path3);
-  const next = {
-    ...current,
-    taskId: trimmedTaskId,
-    updatedAt: patch.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
-  };
-  if (patch.agentId !== void 0) {
-    const agentId = patch.agentId.trim();
-    if (agentId) next.agentId = agentId;
-    else delete next.agentId;
+  async listObjects(bucket, prefix) {
+    const objects = [];
+    const stream = this.inner.listObjectsV2(bucket, prefix, true);
+    await new Promise((resolve7, reject) => {
+      stream.on("data", (obj) => {
+        if (!obj.name) return;
+        objects.push({
+          name: obj.name,
+          size: typeof obj.size === "number" ? obj.size : 0,
+          lastModified: obj.lastModified ?? null,
+          ...typeof obj.etag === "string" ? { etag: obj.etag } : {}
+        });
+      });
+      stream.on("error", reject);
+      stream.on("end", () => resolve7());
+    });
+    return objects;
   }
-  if (patch.messageId !== void 0) {
-    const messageId = patch.messageId.trim();
-    if (messageId) next.messageId = messageId;
-    else delete next.messageId;
+  async statObject(bucket, objectKey) {
+    const stat = await this.inner.statObject(bucket, objectKey);
+    return {
+      size: typeof stat.size === "number" ? stat.size : 0,
+      metaData: stat.metaData
+    };
   }
-  if (patch.action !== void 0) {
-    const action = patch.action.trim();
-    if (action) next.action = action;
-    else delete next.action;
+  async removeObject(bucket, objectKey) {
+    await this.inner.removeObject(bucket, objectKey);
   }
-  if (patch.status !== void 0) {
-    next.status = patch.status;
+  async getObjectBuffer(bucket, objectKey) {
+    const stream = await this.inner.getObject(bucket, objectKey);
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
   }
-  writeRegistry(path3, next);
-}
-function loadWebIdeAgentId(workdir, taskId) {
-  return readRegistry(registryPath(workdir, taskId)).agentId;
-}
-function saveWebIdeAgentId(workdir, taskId, agentId) {
-  syncWebIdeTaskState(workdir, taskId, { agentId });
+};
+
+// src/commands/connect/apm-log-minio.ts
+async function fetchApmLogStorage(cfg2) {
+  const api = createApmApiClient(cfg2);
+  return api.cli.getApmLogStorage(void 0);
 }
-function clearWebIdeAgentId(workdir, taskId) {
-  const path3 = registryPath(workdir, taskId);
-  if (!existsSync7(path3)) return;
-  syncWebIdeTaskState(workdir, taskId, { agentId: "" });
+async function createApmLogMinioClient(cfg2) {
+  const storage = await fetchApmLogStorage(cfg2);
+  return {
+    client: new MinioClient({
+      endPoint: storage.endpoint,
+      port: storage.port,
+      useSSL: storage.useSsl,
+      accessKey: storage.accessKey,
+      secretKey: storage.secretKey
+    }),
+    bucket: storage.bucket,
+    ...storage.publicEndpoint ? { publicEndpoint: storage.publicEndpoint } : {}
+  };
 }
-function loadWebIdeDesignAgentId(workdir, taskId) {
-  return readRegistry(registryPath(workdir, taskId, DESIGN_AGENT_FILE)).agentId;
+
+// src/commands/connect/webide-message-log.ts
+var SYNC_INTERVAL_MS = 2e3;
+function webIdeEventsObjectPrefix(taskId, messageId) {
+  return `events/webide/${taskId}/${messageId}/`;
 }
-function saveWebIdeDesignAgentId(workdir, taskId, agentId) {
-  const trimmedTaskId = taskId.trim();
-  if (!trimmedTaskId) return;
-  const path3 = registryPath(workdir, trimmedTaskId, DESIGN_AGENT_FILE);
-  const current = readRegistry(path3);
-  writeRegistry(path3, {
-    ...current,
-    taskId: trimmedTaskId,
-    agentId: agentId.trim() || void 0,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
+async function putDirtyEvents(minio, bucket, prefix, events) {
+  for (const event of events) {
+    const key = `${prefix}${event.index}.json`;
+    const body = Buffer.from(
+      JSON.stringify({
+        index: event.index,
+        type: event.type,
+        data: event.data
+      }),
+      "utf8"
+    );
+    await minio.putObject(bucket, key, body, {
+      "Content-Type": "application/json"
+    });
+  }
 }
-function clearWebIdeDesignAgentId(workdir, taskId) {
-  const path3 = registryPath(workdir, taskId, DESIGN_AGENT_FILE);
-  if (!existsSync7(path3)) return;
-  const current = readRegistry(path3);
-  const next = { ...current };
-  delete next.agentId;
-  writeRegistry(path3, {
-    ...next,
-    taskId: taskId.trim(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+async function upsertLogHeader(cfg2, ctx, patch, objectPrefix) {
+  const api = createApmApiClient(cfg2);
+  await api.cli.webideUpsertMessageLog({
+    messageId: ctx.messageId,
+    agentId: ctx.agentId,
+    objectPrefix,
+    ...patch
   });
 }
-
-// src/commands/clean-webide-cache.ts
-import { existsSync as existsSync8, rmSync as rmSync2 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
-async function purgeCursorAgentStoreForAgent(cfg2, agentId, workspaceRef) {
-  const trimmedAgentId = agentId.trim();
-  if (!trimmedAgentId) return false;
-  const store = createRemoteLocalAgentStore(cfg2);
-  const runIds = [];
-  let cursor;
-  do {
-    const page = await store.runs.list({
-      filter: {
-        agentIds: [trimmedAgentId],
-        ...cursor ? { cursor } : {},
-        limit: 200
+function createThrottledWebIdeMessageLogSync(cfg2, ctx, onError, options) {
+  let lastRunAt = 0;
+  let timer;
+  let latestSession;
+  let syncChain = Promise.resolve();
+  let minio;
+  let bucket = "";
+  let firstLogNotified = false;
+  const resolvePrefix = () => options?.objectPrefixOverride?.trim() || webIdeEventsObjectPrefix(ctx.taskId, ctx.messageId);
+  const ensureMinio = async () => {
+    if (minio) return;
+    const created = await createApmLogMinioClient(cfg2);
+    minio = created.client;
+    bucket = created.bucket;
+    await minio.ensureBucket(bucket);
+  };
+  const notifyFirstLog = async () => {
+    if (firstLogNotified) return;
+    firstLogNotified = true;
+    try {
+      await options?.onFirstLogSynced?.();
+    } catch (err) {
+      firstLogNotified = false;
+      onError(err);
+    }
+  };
+  const syncDirtyEventsOnce = async (session) => {
+    const events = session.getDirtyEvents();
+    if (events.length === 0) return;
+    lastRunAt = Date.now();
+    try {
+      await ensureMinio();
+      const prefix = resolvePrefix();
+      await putDirtyEvents(minio, bucket, prefix, events);
+      await upsertLogHeader(
+        cfg2,
+        ctx,
+        {
+          eventCount: session.getEventCount()
+        },
+        prefix
+      );
+      session.clearDirtyIfUnchanged(events);
+      await notifyFirstLog();
+    } 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 {
+    async markRun(runId, runStatus, lastError, tokenUsage) {
+      try {
+        await upsertLogHeader(
+          cfg2,
+          ctx,
+          {
+            runId,
+            runStatus,
+            lastError: lastError ?? null,
+            ...tokenUsage ? { tokenUsage } : {}
+          },
+          resolvePrefix()
+        );
+      } catch (err) {
+        onError(err);
+      }
+    },
+    schedule(session) {
+      latestSession = session;
+      const now = Date.now();
+      const elapsed = now - lastRunAt;
+      if (elapsed >= SYNC_INTERVAL_MS) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+        enqueueSync(session);
+        return;
       }
-    });
-    for (const run of page.items) {
-      runIds.push(run.runId);
-    }
-    cursor = page.nextCursor;
-  } while (cursor);
-  await store.runs.delete({ filter: { agentIds: [trimmedAgentId] } });
-  await store.agents.delete({ filter: { agentIds: [trimmedAgentId] } });
-  const workdir = workspaceRef?.trim();
-  if (workdir) {
-    await purgeLocalSqliteAgentData({
-      workspaceRef: workdir,
-      agentId: trimmedAgentId,
-      runIds
-    });
-  }
-  if (runIds.length > 0) {
-    try {
-      const api = createApmApiClient(cfg2);
-      await api.cli.cursorStoreDeleteRunEvents({ runIds });
-    } catch (err) {
-      console.warn(
-        `[apm] \u6E05\u7406\u5E73\u53F0 runEvents \u5931\u8D25 agentId=${trimmedAgentId}:`,
-        err instanceof Error ? err.message : err
-      );
+      if (timer) return;
+      timer = setTimeout(() => {
+        timer = void 0;
+        if (latestSession) enqueueSync(latestSession);
+      }, SYNC_INTERVAL_MS - elapsed);
+    },
+    async flush(session) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      await syncChain;
+      await drainDirtyEvents(session);
     }
-  }
-  return true;
+  };
 }
-async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
-  const trimmedTaskId = taskId.trim();
-  const trimmedWorkdir = workdir.trim();
-  if (!trimmedTaskId || !trimmedWorkdir) {
-    return;
-  }
-  const agentId = loadWebIdeAgentId(trimmedWorkdir, trimmedTaskId);
-  if (agentId) {
-    try {
-      const purged = await purgeCursorAgentStoreForAgent(
-        cfg2,
-        agentId,
-        trimmedWorkdir
-      );
-      if (purged) {
-        console.log(
-          `[apm] \u5DF2\u6E05\u7406 Cursor agent store agentId=${agentId} taskId=${trimmedTaskId}`
-        );
-      }
-    } catch (err) {
-      console.warn(
-        `[apm] \u6E05\u7406 Cursor agent store \u5931\u8D25 agentId=${agentId}:`,
-        err instanceof Error ? err.message : err
-      );
+
+// src/commands/connect/ensure-message-reply.ts
+var DEFAULT_REPLY = "\u4EFB\u52A1\u5DF2\u5B8C\u6210\u3002";
+function resolveMessageReplyFallback(fallback) {
+  for (const candidate of [
+    fallback.assistantText,
+    fallback.result,
+    fallback.createPlan
+  ]) {
+    const trimmed = candidate?.trim();
+    if (trimmed) {
+      return trimmed;
     }
-  } else {
-    console.log(
-      `[apm] \u65E0 WebIDE agentId\uFF0C\u8DF3\u8FC7 agent store \u6E05\u7406 taskId=${trimmedTaskId}`
-    );
-  }
-  const dir = resolve7(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
-  if (existsSync8(dir)) {
-    rmSync2(dir, { recursive: true, force: true });
-    console.log(`[apm] \u5DF2\u6E05\u7406 WebIDE \u7F13\u5B58 ${dir}`);
-  } else {
-    console.log(`[apm] WebIDE \u7F13\u5B58\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7 ${dir}`);
   }
+  return DEFAULT_REPLY;
 }
 
-// src/commands/connect/webide-ask-question.ts
-function asString5(value) {
-  return typeof value === "string" ? value.trim() : "";
+// src/commands/sync-webide-agent.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync6,
+  unlinkSync,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { join as join6 } from "path";
+var REVISION_FILE = ".webide-agent.json";
+var RULE_KEY = /^[a-z0-9_]+$/;
+function withTrailingNewline(text) {
+  return text.endsWith("\n") ? text : `${text}
+`;
 }
-function parseQuestions(args) {
-  const title = asString5(args.title) || void 0;
-  const raw = args.questions;
-  if (!Array.isArray(raw) || raw.length === 0) {
-    throw new Error("AskQuestion \u7F3A\u5C11 questions");
-  }
-  const questions = [];
-  for (const item of raw) {
-    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
-    const row = item;
-    const id = asString5(row.id);
-    const prompt = asString5(row.prompt);
-    const optionsRaw = row.options;
-    if (!id || !prompt || !Array.isArray(optionsRaw)) continue;
-    const options = [];
-    for (const opt of optionsRaw) {
-      if (!opt || typeof opt !== "object" || Array.isArray(opt)) continue;
-      const o = opt;
-      const oid = asString5(o.id);
-      const label = asString5(o.label);
-      if (oid && label) options.push({ id: oid, label });
-    }
-    if (options.length < 2) {
-      throw new Error(`AskQuestion \u95EE\u9898 ${id} \u81F3\u5C11\u9700\u8981 2 \u4E2A\u9009\u9879`);
+function readRevision(apmDir) {
+  const path = toFsPath(join6(apmDir, REVISION_FILE));
+  if (!existsSync6(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    if (parsed?.version === 1 && parsed.revision?.trim()) {
+      return parsed.revision.trim();
     }
-    questions.push({ id, prompt, options });
-  }
-  if (questions.length === 0) {
-    throw new Error("AskQuestion \u65E0\u6709\u6548\u95EE\u9898");
+  } catch {
+    return null;
   }
-  return { title, questions };
+  return null;
 }
-async function fetchAssumptionAnswersAndContinueAssessment(options) {
-  const { cfg: cfg2, taskId, questionIds, title } = options;
+function writeRevision(apmDir, revision) {
+  writeFileSync4(
+    toFsPath(join6(apmDir, REVISION_FILE)),
+    `${JSON.stringify({ version: 1, revision }, null, 2)}
+`,
+    "utf8"
+  );
+}
+async function syncWebIdeAgentFiles(workdir, cfg2) {
   const api = createApmApiClient(cfg2);
-  const list = await api.cli.webideListAssumptions({ taskId });
-  const byId = new Map(list.assumptions.map((a) => [a.questionId, a]));
-  const ids = questionIds && questionIds.length > 0 ? questionIds : list.assumptions.filter((a) => a.status === "RESOLVED").map((a) => a.questionId);
-  if (ids.length === 0) {
-    throw new Error("\u6CA1\u6709\u5DF2\u786E\u8BA4\u7684\u5047\u8BBE");
+  const bundle = await api.cli.webideAgentConfig();
+  const revision = bundle.revision?.trim();
+  if (!revision) {
+    throw new Error("[apm] \u5E73\u53F0\u672A\u8FD4\u56DE WebIDE \u89C4\u5219\u7248\u672C");
   }
-  const answers = [];
-  for (const id of ids) {
-    const row = byId.get(id);
-    if (!row || row.status !== "RESOLVED") {
-      throw new Error(`\u5047\u8BBE\u5C1A\u672A\u5168\u90E8\u786E\u8BA4: ${id}`);
-    }
-    answers.push({
-      questionId: id,
-      prompt: row.prompt,
-      selectedOptionId: row.selectedOptionId,
-      customAnswer: row.customAnswer,
-      resolution: row.resolution
-    });
+  const apmDir = workspaceApmDir(workdir);
+  mkdirSync5(toFsPath(apmDir), { recursive: true });
+  if (readRevision(apmDir) === revision) {
+    return { revision, wrote: false, ruleCount: bundle.rules?.length ?? 0 };
   }
-  console.log(
-    `[apm] \u5047\u8BBE\u7ED3\u679C\u5DF2\u62C9\u53D6 taskId=${taskId} count=${answers.length}`
+  const rulesDir = join6(apmDir, "rules");
+  mkdirSync5(toFsPath(rulesDir), { recursive: true });
+  writeFileSync4(
+    toFsPath(join6(apmDir, "AGENTS.md")),
+    withTrailingNewline(bundle.guide ?? ""),
+    "utf8"
   );
-  return JSON.stringify({ title, answers }, null, 2);
-}
-function createWebIdeAskQuestionExecute(options) {
-  const { cfg: cfg2, taskId, onAwaitingAssumptions } = options;
-  return async (args) => {
-    const parsed = parseQuestions(args);
-    const api = createApmApiClient(cfg2);
-    console.log(
-      `[apm] AskQuestion \u521B\u5EFA\u5F85\u786E\u8BA4\u9879 taskId=${taskId} count=${parsed.questions.length}`
+  const keep = /* @__PURE__ */ new Set();
+  for (const rule of bundle.rules ?? []) {
+    const key = rule.key?.trim() ?? "";
+    if (!RULE_KEY.test(key)) {
+      throw new Error(`[apm] \u975E\u6CD5\u89C4\u5219\u540D: ${key || "(\u7A7A)"}`);
+    }
+    keep.add(`${key}.md`);
+    writeFileSync4(
+      toFsPath(join6(rulesDir, `${key}.md`)),
+      withTrailingNewline(rule.body ?? ""),
+      "utf8"
     );
-    await api.cli.webideReplaceAssumptions({
-      taskId,
-      title: parsed.title,
-      questions: parsed.questions
-    });
-    await api.cli.webideRunAction({
-      taskId,
-      action: "await-assumptions"
-    });
-    onAwaitingAssumptions?.();
-    return [
-      "\u5047\u8BBE\u5DF2\u63D0\u4EA4\uFF0C\u5DE5\u4F5C\u6D41\u8FDB\u5165\u300C\u5F85\u786E\u8BA4\u5047\u8BBE\u300D\u3002",
-      "\u672C\u8F6E\u5FC5\u987B\u7ACB\u5373\u7ED3\u675F\uFF1A\u4E0D\u8981\u7EE7\u7EED\u8BC4\u4F30\uFF0C\u4E0D\u8981\u8C03\u7528 RecommendPlan\uFF0C\u4E0D\u8981\u518D\u6B21\u8C03\u7528 AskQuestion\u3002",
-      "\u7528\u6237\u786E\u8BA4\u540E\uFF0C\u4E0B\u4E00\u8F6E\u4F1A\u5E26\u4E0A\u7B54\u6848\u5E76\u7EE7\u7EED\u8BC4\u4F30\u3002"
-    ].join("");
+  }
+  for (const name of readdirSync3(toFsPath(rulesDir))) {
+    if (!name.endsWith(".md")) continue;
+    if (keep.has(name)) continue;
+    unlinkSync(toFsPath(join6(rulesDir, name)));
+  }
+  writeRevision(apmDir, revision);
+  return {
+    revision,
+    wrote: true,
+    ruleCount: bundle.rules?.length ?? 0
   };
 }
 
+// src/commands/init.ts
+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\u6309 WebIDE \u81EA\u52A8\u521D\u59CB\u5316\u2026`
+  );
+  await ensureWorkspaceApmDirForInit(workdir);
+  console.log(`[apm] \u5DF2\u521B\u5EFA\u5DE5\u4F5C\u533A\u76EE\u5F55\uFF1A${workspaceApmDir(workdir)}`);
+  return { didInit: true };
+}
+
 // src/commands/connect/pre-step-cache.ts
 function taskWorkdirKey(taskId, workdir) {
   return `${taskId}\0${workdir}`;
@@ -4501,9 +3380,9 @@ async function ensureWebIdePullRequests(cfg2, taskId, workdir) {
 }
 
 // src/commands/sync-webide-attachments.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join6 } from "path";
-var MANIFEST_FILE2 = ".sync-manifest.json";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { join as join7 } from "path";
+var MANIFEST_FILE = ".sync-manifest.json";
 async function downloadAttachment(cfg2, attachmentId) {
   const base = cfg2.baseUrl.trim().replace(/\/+$/, "");
   const url = `${base}/api/v1/tasks/attachments/file?${new URLSearchParams({
@@ -4518,13 +3397,13 @@ async function downloadAttachment(cfg2, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path3 = join6(dir, MANIFEST_FILE2);
-  if (!existsSync9(path3)) {
+  const path = join7(dir, MANIFEST_FILE);
+  if (!existsSync7(path)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync7(path3, "utf8")
+      readFileSync7(path, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -4534,15 +3413,15 @@ function loadManifest(dir) {
   return { version: 1, attachments: {} };
 }
 function saveManifest(dir, manifest) {
-  writeFileSync6(
-    join6(dir, MANIFEST_FILE2),
+  writeFileSync5(
+    join7(dir, MANIFEST_FILE),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
 function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync9(dest)) return false;
+  if (!entry || !existsSync7(dest)) return false;
   if (entry.name !== item.name) return false;
   const createdAt = item.createdAt ?? "";
   return entry.createdAt === createdAt;
@@ -4557,7 +3436,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
   const nextManifest = { version: 1, attachments: {} };
   const names = [];
   for (const item of attachments) {
-    const dest = join6(dir, item.name);
+    const dest = join7(dir, item.name);
     const entry = manifest.attachments[item.id];
     const createdAt = item.createdAt ?? "";
     names.push(item.name);
@@ -4567,7 +3446,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
       continue;
     }
     const buffer = await downloadAttachment(cfg2, item.id);
-    writeFileSync6(dest, buffer);
+    writeFileSync5(dest, buffer);
     nextManifest.attachments[item.id] = {
       name: item.name,
       createdAt
@@ -4588,9 +3467,9 @@ async function syncWebIdeAttachments(cfg2, taskId, workdir, attachments) {
 }
 
 // src/commands/sync-webide-design.ts
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync5, writeFileSync as writeFileSync7 } from "fs";
-import { join as join7 } from "path";
+import { createHash } from "crypto";
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync4, writeFileSync as writeFileSync6 } from "fs";
+import { join as join8 } from "path";
 
 // src/opc-shared-types.ts
 function webIdeDesignObjectKey(taskId, fileName) {
@@ -4606,17 +3485,17 @@ function webIdeDesignArtifactContentType(name) {
 }
 
 // src/commands/sync-webide-design.ts
-var MANIFEST_FILE3 = ".sync-manifest.json";
+var MANIFEST_FILE2 = ".sync-manifest.json";
 function hashBuffer(buf) {
-  return createHash3("sha256").update(buf).digest("hex");
+  return createHash("sha256").update(buf).digest("hex");
 }
 function loadManifest2(dir) {
-  const path3 = join7(dir, MANIFEST_FILE3);
-  if (!existsSync10(path3)) {
+  const path = join8(dir, MANIFEST_FILE2);
+  if (!existsSync8(path)) {
     return { version: 1, files: {} };
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
     if (parsed?.version === 1 && parsed.files && typeof parsed.files === "object") {
       return parsed;
     }
@@ -4625,8 +3504,8 @@ function loadManifest2(dir) {
   return { version: 1, files: {} };
 }
 function saveManifest2(dir, manifest) {
-  writeFileSync7(
-    join7(dir, MANIFEST_FILE3),
+  writeFileSync6(
+    join8(dir, MANIFEST_FILE2),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
@@ -4654,13 +3533,13 @@ async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
   for (const art of artifacts) {
     const name = art.name?.trim();
     if (!name || !isWebIdeDesignArtifactName(name)) continue;
-    const localPath = join7(dir, name);
+    const localPath = join8(dir, name);
     const entry = manifest.files[name];
-    if (entry?.contentHash === art.contentHash && existsSync10(localPath)) {
+    if (entry?.contentHash === art.contentHash && existsSync8(localPath)) {
       continue;
     }
     const buf = await downloadDesignFile(cfg2, taskId, name);
-    writeFileSync7(localPath, buf);
+    writeFileSync6(localPath, buf);
     manifest.files[name] = { contentHash: hashBuffer(buf) };
     synced.push(name);
   }
@@ -4669,12 +3548,12 @@ async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
 }
 function listLocalDesignArtifactFiles(taskId, workdir) {
   const dir = webideDesignDir(taskId, workdir);
-  if (!existsSync10(dir)) return [];
+  if (!existsSync8(dir)) return [];
   const out = [];
-  for (const name of readdirSync5(dir)) {
+  for (const name of readdirSync4(dir)) {
     if (!isWebIdeDesignArtifactName(name)) continue;
-    const absPath = join7(dir, name);
-    if (!statSync5(absPath).isFile()) continue;
+    const absPath = join8(dir, name);
+    if (!statSync4(absPath).isFile()) continue;
     const buf = readFileSync8(absPath);
     if (buf.length === 0) continue;
     out.push({ name, absPath, contentHash: hashBuffer(buf) });
@@ -4759,8 +3638,6 @@ function startActionForInbound(action) {
     case "request-develop":
     case "skip-plan":
       return "start-develop";
-    case "request-start-project":
-      return "start-project";
     case "request-execute-sql":
       return "start-execute-sql";
     case "request-bugfix":
@@ -4795,9 +3672,6 @@ function completeActionForInbound(action) {
     case "skip-plan":
     case "start-develop":
       return "complete-develop";
-    case "request-start-project":
-    case "start-project":
-      return "complete-project";
     case "request-execute-sql":
     case "start-execute-sql":
       return "complete-execute-sql";
@@ -4869,9 +3743,6 @@ var WEBIDE_CODE_CHANGE_ACTIONS = /* @__PURE__ */ new Set([
 function shouldCommitAfterWebIdeMessage(action) {
   return WEBIDE_CODE_CHANGE_ACTIONS.has(action);
 }
-function isStartLocalServicesAction(action) {
-  return action === "enter-manual-test" || action === "skip-test" || action === "request-start-project";
-}
 function isDesignAction(action) {
   return action === "request-design" || action === "request-revise-design";
 }
@@ -4882,11 +3753,11 @@ function syncLocalTaskStatus(workdir, taskId, msg2, status) {
     status
   });
 }
-async function updateStatus2(cfg2, messageId, status) {
+async function updateStatus(cfg2, messageId, status) {
   const api = createApmApiClient(cfg2);
   await api.cli.webideUpdateMessageStatus({ id: messageId, status });
 }
-async function setError2(cfg2, messageId, error) {
+async function setError(cfg2, messageId, error) {
   const api = createApmApiClient(cfg2);
   await api.cli.webideSetMessageError({ id: messageId, error });
 }
@@ -4905,7 +3776,7 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
   console.log(
     `[apm] webide-message action=${msg2.action}${previousAction ? ` previousAction=${previousAction}` : ""} taskId=${taskId} messageId=${messageId}`
   );
-  await updateStatus2(cfg2, messageId, "TYPING");
+  await updateStatus(cfg2, messageId, "TYPING");
   syncLocalTaskStatus(workdir, taskId, msg2, "TYPING");
   const eventSession = new EventSession(msg2.content);
   const prepAgentId = loadWebIdeAgentId(workdir, taskId) ?? "webide-cli-prep";
@@ -4996,10 +3867,13 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
       if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
       await runPrepStep(
         "\u51C6\u5907\u7279\u6027\u5206\u652F",
-        async () => runTaskBranch(taskId, { cwd: workdir }),
+        async () => {
+          const projectId = await resolveProjectIdForTask(taskId);
+          return runTaskBranch(taskId, projectId, { cwd: workdir });
+        },
         (branchResult) => {
           markBranchDone(branchCacheKey, workdir);
-          return `kind=${branchResult.kind} branch=${branchResult.branch} baseline=${branchResult.baseline} repos=${branchResult.repos.length}`;
+          return `kind=${branchResult.kind} branch=${branchResult.branch} projectId=${branchResult.projectId} repos=${branchResult.repos.length}`;
         }
       );
     } else {
@@ -5025,43 +3899,6 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
     }
     if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
     const api = createApmApiClient(cfg2);
-    let projectId = null;
-    await runPrepStep(
-      "\u540C\u6B65\u9879\u76EE\u6587\u6863",
-      async () => {
-        try {
-          const baseline = await api.cli.projectBaseBranch({ taskId });
-          projectId = baseline.projectId?.trim() || null;
-          if (!projectId) {
-            return { synced: false, reason: "\u65E0 projectId" };
-          }
-          const docs = await syncProjectDocumentsPull(workdir, void 0, {
-            projectId
-          });
-          return {
-            synced: docs.synced,
-            downloaded: docs.downloaded,
-            deleted: docs.deleted
-          };
-        } catch (err) {
-          console.warn(
-            "[apm] WebIDE \u9879\u76EE\u6587\u6863\u540C\u6B65\u5931\u8D25:",
-            err instanceof Error ? err.message : err
-          );
-          return {
-            synced: false,
-            reason: err instanceof Error ? err.message : String(err)
-          };
-        }
-      },
-      (result) => {
-        if ("reason" in result && result.reason) {
-          return `\u8DF3\u8FC7\uFF1A${result.reason}`;
-        }
-        if (!result.synced) return "\u65E0\u9700\u540C\u6B65";
-        return `downloaded=${result.downloaded ?? 0} deleted=${result.deleted ?? 0}`;
-      }
-    );
     await runPrepStep(
       "\u540C\u6B65\u4EFB\u52A1\u9644\u4EF6",
       async () => {
@@ -5112,18 +3949,17 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
       "running"
     );
     await syncPrepLog();
-    const startLocalServices = isStartLocalServicesAction(effectiveAction);
     const designAction = isDesignAction(effectiveAction);
     const useNewAgent = msg2.useNewAgent === true;
     const toolNames = Array.isArray(msg2.tools) ? msg2.tools.map((t) => String(t).trim()).filter(Boolean) : [];
-    if (useNewAgent && !startLocalServices) {
+    if (useNewAgent) {
       if (designAction) {
         clearWebIdeDesignAgentId(workdir, taskId);
       } else {
         clearWebIdeAgentId(workdir, taskId);
       }
     }
-    const savedAgentId = startLocalServices || useNewAgent ? void 0 : designAction ? loadWebIdeDesignAgentId(workdir, taskId) : loadWebIdeAgentId(workdir, taskId);
+    const savedAgentId = useNewAgent ? void 0 : designAction ? loadWebIdeDesignAgentId(workdir, taskId) : loadWebIdeAgentId(workdir, taskId);
     const promptPayload = toolNames.includes("MysqlExecute") ? continuePayload ?? parseWebIdePromptPayload(msg2.content) : null;
     const sqlExecutionId = toolNames.includes("MysqlExecute") && typeof promptPayload?.executionId === "string" ? promptPayload.executionId.trim() : void 0;
     if (toolNames.includes("MysqlExecute") && !sqlExecutionId) {
@@ -5132,7 +3968,6 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
       );
     }
     const persistAgentId = (agentId) => {
-      if (startLocalServices) return;
       if (designAction) {
         saveWebIdeDesignAgentId(workdir, taskId, agentId);
       } else {
@@ -5158,7 +3993,7 @@ ${assumptionAnswersText}` : msg2.content,
         forceSend: true,
         eventSession,
         appendMessageContent: (content) => appendContent(cfg2, messageId, content),
-        askQuestionExecute: !startLocalServices && toolNames.includes("AskQuestion") ? createWebIdeAskQuestionExecute({
+        askQuestionExecute: toolNames.includes("AskQuestion") ? createWebIdeAskQuestionExecute({
           cfg: cfg2,
           taskId,
           onAwaitingAssumptions: () => {
@@ -5170,11 +4005,10 @@ ${assumptionAnswersText}` : msg2.content,
         enableAskQuestion: false,
         enableWebIdePlanTools: false,
         enableMysqlTools: false,
-        enablePtySessionMcp: startLocalServices || toolNames.includes("PtySession"),
         sqlExecutionId,
         toolNames,
         enableSandbox: false,
-        onInvalidatePersistedAgentId: startLocalServices ? void 0 : () => {
+        onInvalidatePersistedAgentId: () => {
           if (designAction) {
             clearWebIdeDesignAgentId(workdir, taskId);
           } else {
@@ -5227,9 +4061,7 @@ ${assumptionAnswersText}` : msg2.content,
         }
       }
     );
-    if (!startLocalServices) {
-      persistAgentId(outcome.agentId);
-    }
+    persistAgentId(outcome.agentId);
     const tokenUsage = outcome.usage != null ? {
       modelId: outcome.modelId ?? (msg2.model?.trim() || void 0),
       inputTokens: outcome.usage.inputTokens,
@@ -5263,7 +4095,7 @@ ${assumptionAnswersText}` : msg2.content,
           );
         }
       }
-      await setError2(cfg2, messageId, detail);
+      await setError(cfg2, messageId, detail);
       syncLocalTaskStatus(workdir, taskId, msg2, "FAILED");
       return;
     }
@@ -5288,7 +4120,7 @@ ${assumptionAnswersText}` : msg2.content,
           );
         }
       }
-      await updateStatus2(cfg2, messageId, "CANCELLED");
+      await updateStatus(cfg2, messageId, "CANCELLED");
       syncLocalTaskStatus(workdir, taskId, msg2, "CANCELLED");
       return;
     }
@@ -5333,7 +4165,7 @@ ${assumptionAnswersText}` : msg2.content,
           detail,
           tokenUsage
         );
-        await setError2(cfg2, messageId, detail);
+        await setError(cfg2, messageId, detail);
         syncLocalTaskStatus(workdir, taskId, msg2, "FAILED");
         return;
       }
@@ -5410,16 +4242,6 @@ ${assumptionAnswersText}` : msg2.content,
         }
       }
     }
-    if (projectId) {
-      try {
-        await syncProjectDocumentsPush(cfg2, workdir, void 0, { projectId });
-      } catch (err) {
-        console.warn(
-          "[apm] WebIDE \u9879\u76EE\u6587\u6863\u63A8\u9001\u5931\u8D25:",
-          err instanceof Error ? err.message : err
-        );
-      }
-    }
     await logSyncRef.current?.markRun(
       outcome.runId,
       "finished",
@@ -5434,21 +4256,11 @@ ${assumptionAnswersText}` : msg2.content,
         `[apm] \u672C\u8F6E\u505C\u5728\u5F85\u786E\u8BA4\u5047\u8BBE\uFF0C\u8DF3\u8FC7 complete action=${effectiveAction} taskId=${taskId}`
       );
     }
-    await updateStatus2(cfg2, messageId, "SUCCESS");
+    await updateStatus(cfg2, messageId, "SUCCESS");
     syncLocalTaskStatus(workdir, taskId, msg2, "SUCCESS");
     console.log(
       `[apm] webide-message \u5B8C\u6210 action=${msg2.action}${previousAction ? ` previousAction=${previousAction}` : ""} messageId=${messageId} agentId=${outcome.agentId}`
     );
-    if (effectiveAction === "request-accept" || effectiveAction === "start-accept") {
-      try {
-        await cleanWebIdeWorkspaceCache(taskId, workdir, cfg2);
-      } catch (err) {
-        console.warn(
-          "[apm] \u5408\u5E76 PR \u540E\u6E05\u7406 WebIDE agent \u7F13\u5B58\u5931\u8D25:",
-          err instanceof Error ? err.message : err
-        );
-      }
-    }
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     console.error(`[apm] webide-message \u5931\u8D25: ${detail}`);
@@ -5459,7 +4271,7 @@ ${assumptionAnswersText}` : msg2.content,
       clearWebIdeAgentId(workdir, taskId);
     }
     try {
-      await setError2(cfg2, messageId, detail);
+      await setError(cfg2, messageId, detail);
     } catch (statusErr) {
       console.error(
         "[apm] \u5199\u5165 WebIDE FAILED \u5931\u8D25:",
@@ -5483,23 +4295,7 @@ ${assumptionAnswersText}` : msg2.content,
 
 // src/commands/connect/core/worker/handlers/index.ts
 async function dispatchWorkerJob(cfg2, msg2, signal) {
-  switch (msg2.type) {
-    case "webide-message":
-      await handleWebIdeInboundMessage(cfg2, msg2, signal);
-      return;
-    case "webide-start-project":
-      await handleStartProject(cfg2, msg2, signal);
-      return;
-    case "webide-package":
-      await handleWebIdePackage(cfg2, msg2, signal);
-      return;
-    default: {
-      const unknown = msg2;
-      throw new Error(
-        `\u672A\u77E5 WebIDE worker \u4EFB\u52A1: ${unknown.type ?? "unknown"}`
-      );
-    }
-  }
+  await handleWebIdeInboundMessage(cfg2, msg2, signal);
 }
 
 // src/commands/connect/core/worker/worker-script.ts