ai-project-manage-cli 8.1.24 → 8.2.19

package/dist/worker-script.js

@@ -115,10 +115,38 @@ 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"
@@ -179,15 +207,6 @@ 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");
@@ -203,12 +222,10 @@ 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 } : {},
-      ...socketServer ? { socketServer } : {}
+      ...clientMachineId ? { clientMachineId } : {}
     };
   } catch {
     return null;
@@ -231,14 +248,10 @@ 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 } : {},
-    ...socketServer ? { socketServer } : {}
+    ...clientMachineId ? { clientMachineId } : {}
   };
   mkdirSync(APM_CONFIG_DIR, { recursive: true });
   writeFileSync(APM_CONFIG_PATH, JSON.stringify(normalized, null, 2) + "\n", {
@@ -271,8 +284,8 @@ function toFsPath(inputPath) {
   }
   return `\\\\?\\${normalized}`;
 }
-function normalizeWorkdirPath(path) {
-  let normalized = path.trim().replace(/\\/g, "/").normalize("NFC");
+function normalizeWorkdirPath(path3) {
+  let normalized = path3.trim().replace(/\\/g, "/").normalize("NFC");
   if (normalized.startsWith("//?/")) {
     normalized = normalized.slice(4);
   }
@@ -359,66 +372,84 @@ 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);
-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");
-  }
-  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");
+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;
+      }
+    }
   }
-  if (!/\bServerAliveCountMax=/.test(base)) {
-    extras.push("-o", "ServerAliveCountMax=3");
+  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;
   }
-  return extras.length ? `${base} ${extras.join(" ")}` : base;
 }
-function gitExecEnv() {
-  return {
-    ...process.env,
-    GIT_SSH_COMMAND: mergeGitSshCommand(process.env.GIT_SSH_COMMAND),
-    // 避免 credential helper / askpass 在无 TTY 时挂起
-    GIT_TERMINAL_PROMPT: "0"
-  };
+async function tryReadHttpsGitOriginUrl(cwd) {
+  const raw = await tryReadGitOriginUrl(cwd);
+  if (!raw) return null;
+  return toHttpsGitRemoteUrl(raw);
 }
-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;
+
+// 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 };
 }
-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;
+async function execGit(cwd, args, quiet = false) {
   try {
-    const { stdout, stderr } = await execFileAsync("git", args, {
+    const { stdout, stderr } = await execFileAsync2("git", args, {
       cwd,
       env: gitExecEnv(),
       encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024,
-      ...timeoutMs > 0 ? { timeout: timeoutMs, killSignal: "SIGTERM" } : {}
+      maxBuffer: 10 * 1024 * 1024
     });
     if (!quiet && stderr.trim()) {
       process.stderr.write(stderr);
@@ -426,229 +457,113 @@ async function execGit(cwd, args, quietOrOptions = 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();
 }
-var FEATURE_BRANCH_RE = /^feat\/task-(.+)$/;
-function isFeatureBranchName(branch) {
-  return FEATURE_BRANCH_RE.test(branch.trim().replace(/^origin\//, ""));
-}
-function resolveGitScript(name) {
-  return join3(dirname(fileURLToPath(import.meta.url)), "scripts", name);
+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`
+  );
 }
-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 ?? []];
+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 {
-    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);
+    await execGit(cwd, ["fetch", "origin", head], true);
+    await execGit(cwd, ["rev-parse", "--verify", `origin/${head}`], true);
+    headRef = `origin/${head}`;
+  } catch {
+    await execGit(cwd, ["rev-parse", "--verify", head], true);
+  }
+  const baseRef = `origin/${base}`;
+  const ahead = (await execGit(cwd, ["rev-list", "--count", `${baseRef}..${headRef}`], true)).trim();
+  if ((Number.parseInt(ahead, 10) || 0) <= 0) {
+    return false;
+  }
+  try {
+    await execGit(cwd, ["diff", "--quiet", `${baseRef}...${headRef}`], true);
+    return false;
+  } catch {
     return true;
-  } 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}` : ""}`);
   }
 }
-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
-  });
+var FEATURE_BRANCH_RE = /^feat\/task-(.+)$/;
+function isFeatureBranchName(branch) {
+  return FEATURE_BRANCH_RE.test(branch.trim().replace(/^origin\//, ""));
 }
-async function ensureFeatureBranch(cwd, branch, baselineBranch) {
-  await runGitScript("ensure_feature_branch.sh", {
-    cwd,
-    args: [branch, baselineBranch],
-    timeoutMs: GIT_PUSH_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 pushCurrentBranch(cwd) {
-  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";
-function isSimpleChildDirName(name) {
-  if (!name || name === "." || name === "..") return false;
-  if (name.includes("/") || name.includes("\\")) return false;
-  return true;
-}
-function resolveReposManifestPath(explicit) {
-  const fromOpt = explicit?.trim() || "";
-  if (fromOpt) return fromOpt;
-  const fromEnv = process.env.APM_REPOS_MANIFEST?.trim() || "";
-  if (fromEnv) return fromEnv;
-  return null;
-}
-function loadHomeRepositoryEntries(manifestPath2) {
-  const label = manifestPath2.trim();
-  if (!label) {
-    throw new Error("[apm] \u591A\u4ED3\u6E05\u5355\u8DEF\u5F84\u4E3A\u7A7A");
-  }
-  const path = toFsPath(label);
-  if (!existsSync2(path)) {
-    throw new Error(`[apm] \u672A\u627E\u5230\u591A\u4ED3\u6E05\u5355 ${label}`);
-  }
-  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 ${label} \u5931\u8D25: ${detail}`);
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(
-      `[apm] ${label} \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] ${label} \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] ${label}[${pathKey}] \u987B\u4E3A\u975E\u7A7A git \u5730\u5740\u5B57\u7B26\u4E32`
-      );
-    }
-    entries.push({ path: pathKey, remoteUrl: rawVal.trim() });
+  if (!await isGitRepo(cwd)) {
+    return false;
   }
-  entries.sort((a, b) => a.path.localeCompare(b.path));
-  if (entries.length === 0) {
-    throw new Error(`[apm] ${label} \u4E3A\u7A7A\uFF0C\u65E0\u4ED3\u5E93\u53EF\u786E\u8BA4`);
+  const originUrl = await tryReadGitOriginUrl(cwd);
+  if (!originUrl) {
+    console.log("[apm] \u672A\u914D\u7F6E remote.origin\uFF0C\u8DF3\u8FC7 push");
+    return false;
   }
-  return entries;
-}
-function resolveHomeRepositoryAbsolutePaths(workdirInput, entries) {
-  const workdir = resolveWorkdirPath(workdirInput);
-  return entries.map((entry) => resolve3(join4(workdir, entry.path)));
+  await execGit(cwd, ["push", "-u", "origin", "HEAD"]);
+  return true;
 }
 
 // src/utils/workspace-repos.ts
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync2,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync2,
   readdirSync as readdirSync2,
   statSync as statSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-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
+import { basename, dirname, join as join3, relative, resolve as resolve3 } from "path";
 var WORKSPACE_REPOS_MANIFEST = "workspace-repos.json";
 var WORKSPACE_REPOS_VERSION = 1;
 var SKIP_DIR_NAMES = /* @__PURE__ */ new Set([".apm", "node_modules"]);
 function hasGitAt(dir) {
-  return existsSync3(toFsPath(join5(dir, ".git")));
+  return existsSync2(toFsPath(join3(dir, ".git")));
 }
 function isSkippableChildName(name) {
   if (SKIP_DIR_NAMES.has(name)) return true;
@@ -656,21 +571,25 @@ function isSkippableChildName(name) {
   return false;
 }
 function manifestPath(workdir) {
-  return join5(workspaceApmDir(workdir), WORKSPACE_REPOS_MANIFEST);
+  return join3(workspaceApmDir(workdir), WORKSPACE_REPOS_MANIFEST);
 }
 function absoluteRepoPath(workdir, entry) {
-  return resolve4(workdir, entry.path);
+  if (entry.path === "." || entry.path === "") {
+    return workdir;
+  }
+  return resolve3(workdir, entry.path);
 }
 function toRelativeRepoPath(workdir, repoAbs) {
-  return relative(workdir, repoAbs).replace(/\\/g, "/");
+  const rel = relative(workdir, repoAbs).replace(/\\/g, "/");
+  return rel === "" ? "." : rel;
 }
 function normalizeRepoEntry(raw) {
   if (!raw || typeof raw !== "object") return null;
   const o = raw;
   if (typeof o.path !== "string" || !o.path.trim()) return null;
-  const path = o.path.trim().replace(/\\/g, "/");
-  if (path === "." || path.includes("/")) return null;
-  const entry = { path };
+  const entry = {
+    path: o.path.trim().replace(/\\/g, "/")
+  };
   if (typeof o.remoteUrl === "string" && o.remoteUrl.trim()) {
     entry.remoteUrl = o.remoteUrl.trim();
   } else if (o.remoteUrl === null) {
@@ -679,18 +598,18 @@ function normalizeRepoEntry(raw) {
   return entry;
 }
 function readManifest(workdir) {
-  const path = toFsPath(manifestPath(workdir));
-  if (!existsSync3(path)) {
+  const path3 = toFsPath(manifestPath(workdir));
+  if (!existsSync2(path3)) {
     return null;
   }
   try {
     const raw = JSON.parse(
-      readFileSync3(path, "utf8")
+      readFileSync2(path3, "utf8")
     );
     if (raw?.version !== WORKSPACE_REPOS_VERSION) {
       return null;
     }
-    if (raw.kind !== "multi") {
+    if (raw.kind !== "single" && raw.kind !== "multi") {
       return null;
     }
     if (!Array.isArray(raw.repos) || raw.repos.length === 0) {
@@ -705,7 +624,7 @@ function readManifest(workdir) {
     }
     return {
       version: WORKSPACE_REPOS_VERSION,
-      kind: "multi",
+      kind: raw.kind,
       workdir: raw.workdir,
       repos,
       scannedAt: typeof raw.scannedAt === "string" && raw.scannedAt.trim() ? raw.scannedAt : (/* @__PURE__ */ new Date()).toISOString()
@@ -717,8 +636,8 @@ function readManifest(workdir) {
 function writeManifest(workdir, manifest) {
   const apmDir = toFsPath(workspaceApmDir(workdir));
   mkdirSync3(apmDir, { recursive: true });
-  const path = toFsPath(manifestPath(workdir));
-  writeFileSync2(path, `${JSON.stringify(manifest, null, 2)}
+  const path3 = toFsPath(manifestPath(workdir));
+  writeFileSync2(path3, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 function manifestStillValid(workdir, manifest) {
@@ -729,9 +648,6 @@ 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;
@@ -741,8 +657,17 @@ 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 (!existsSync3(fsWorkdir) || !statSync2(fsWorkdir).isDirectory()) {
+  if (!existsSync2(fsWorkdir) || !statSync2(fsWorkdir).isDirectory()) {
     throw new Error(`[apm] \u5DE5\u4F5C\u533A\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55: ${workdir}`);
   }
   const repos = [];
@@ -750,9 +675,9 @@ function scanWorkspaceRepos(workdirInput) {
     if (isSkippableChildName(name)) {
       continue;
     }
-    const childAbs = resolve4(workdir, name);
+    const childAbs = resolve3(workdir, name);
     const childFs = toFsPath(childAbs);
-    if (!existsSync3(childFs) || !statSync2(childFs).isDirectory()) {
+    if (!existsSync2(childFs) || !statSync2(childFs).isDirectory()) {
       continue;
     }
     if (!hasGitAt(childAbs)) {
@@ -763,7 +688,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} \u4E00\u7EA7\u5B50\u76EE\u5F55\u4E2D\u672A\u53D1\u73B0 git \u4ED3\u5E93`
+      `[apm] \u5DE5\u4F5C\u533A ${workdir} \u6839\u76EE\u5F55\u65E0 .git\uFF0C\u4E14\u4E00\u7EA7\u5B50\u76EE\u5F55\u4E2D\u672A\u53D1\u73B0 git \u4ED3\u5E93`
     );
   }
   return {
@@ -791,7 +716,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 repos=${cached.repos.map((r) => r.path).join(", ")}`
+    `[apm] \u8BFB\u53D6\u5DE5\u4F5C\u533A\u4ED3\u5E93\u7F13\u5B58 kind=${cached.kind} repos=${cached.repos.map((r) => r.path).join(", ")}`
   );
   return {
     ...cached,
@@ -829,7 +754,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 repos=${cached.repos.length}`
+        `[apm] \u4F7F\u7528\u7F13\u5B58\u7684\u5DE5\u4F5C\u533A\u4ED3\u5E93\u6E05\u5355 kind=${cached.kind} repos=${cached.repos.length}`
       );
       return cached;
     }
@@ -846,7 +771,7 @@ function resolveWorkspaceRepos(workdirInput, options) {
   }
   writeManifest(workdir, scanned);
   console.log(
-    `[apm] \u5DF2\u626B\u63CF\u5DE5\u4F5C\u533A\u4ED3\u5E93 repos=${scanned.repos.map((r) => r.path).join(", ")} \u2192 .apm/${WORKSPACE_REPOS_MANIFEST}`
+    `[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}`
   );
   return scanned;
 }
@@ -857,69 +782,48 @@ function resolveWorkspaceRepoAbsolutePaths(manifest) {
 }
 function formatRepoLabel(workdir, repoAbs) {
   const rel = toRelativeRepoPath(resolveWorkdirPath(workdir), repoAbs);
-  return rel || basename(repoAbs) || repoAbs;
+  return rel === "." ? basename(repoAbs) || repoAbs : rel;
 }
 
 // src/commands/branch.ts
 var TASK_BRANCH_PREFIX = "feat/task-";
-async function commitWorkspaceReposIfDirty(workdir, message, reposManifest) {
-  const result = await commitTaskReposIfDirty(workdir, message, reposManifest);
-  return result.committed;
+async function localBranchExists(cwd, branch) {
+  try {
+    await execGit(
+      cwd,
+      ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
+      true
+    );
+    return true;
+  } catch {
+    return false;
+  }
 }
-async function commitTaskReposIfDirty(workdir, message, reposManifest) {
-  return syncTaskRepos(workdir, { message, reposManifest });
+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 syncTaskRepos(workdir, options = {}) {
-  const opts = typeof options === "string" ? { message: options } : options;
+async function commitWorkspaceReposIfDirty(workdir, message) {
   const workdirPath = resolveWorkdirPath(workdir);
-  const repoRoots = resolveTaskBranchRepoRoots(
-    workdirPath,
-    opts.reposManifest
-  );
+  const manifest = loadWorkspaceReposCache(workdirPath);
+  const repoRoots = resolveWorkspaceRepoAbsolutePaths(manifest);
   let committed = 0;
-  let commitSkipped = 0;
-  let pushed = 0;
-  let pushSkipped = 0;
-  const failed = [];
-  const message = opts.message;
   for (const gitRoot of repoRoots) {
     const label = formatRepoLabel(workdirPath, gitRoot);
-    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);
+    const did = await commitWorkingTreeIfDirty(gitRoot, message);
+    if (did) {
+      committed += 1;
+      console.log(`[apm] WebIDE \u515C\u5E95\u63D0\u4EA4 @ ${label}`);
     }
   }
-  return {
-    committed,
-    commitSkipped,
-    pushed,
-    pushSkipped,
-    failed,
-    repos: repoRoots
-  };
+  return committed;
 }
 async function pushWorkspaceRepos(workdir) {
   const workdirPath = resolveWorkdirPath(workdir);
@@ -948,99 +852,136 @@ function branchNameForTask(taskId) {
   }
   return `${TASK_BRANCH_PREFIX}${id}`;
 }
-async function ensureTaskFeatureBranch(branch, projectId, options) {
+async function ensureFeatureBranch(branch, baselineBranch, options) {
   const cwd = options.cwd ?? process.cwd();
   const gitRoot = await resolveGitRepoRoot(cwd);
-  await ensureFeatureBranch(gitRoot, branch, projectId);
-  return branch;
-}
-async function resolveProjectIdForTask(taskId) {
-  const trimmedTaskId = taskId.trim();
-  if (!trimmedTaskId) {
-    throw new Error("[apm] taskId \u4E0D\u80FD\u4E3A\u7A7A");
+  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}`);
+  return branch;
+}
+async function runTaskBranch(taskId, options = {}) {
+  const trimmedTaskId = taskId.trim();
+  if (!trimmedTaskId) {
+    throw new Error("[apm] taskId \u4E0D\u80FD\u4E3A\u7A7A");
   }
   const cfg2 = await ensureLoggedConfig();
   const api = createApmApiClient(cfg2);
   const projectBaseline = await api.cli.projectBaseBranch({
     taskId: trimmedTaskId
   });
-  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 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");
   }
-  return projectId;
-}
-function resolveTaskBranchRepoRoots(workdirPath, reposManifest) {
-  const manifestPath2 = resolveReposManifestPath(reposManifest);
-  if (manifestPath2) {
-    const entries = loadHomeRepositoryEntries(manifestPath2);
-    const roots2 = resolveHomeRepositoryAbsolutePaths(workdirPath, entries);
+  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);
     console.log(
-      `[apm] \u8BFB\u53D6\u5916\u90E8\u591A\u4ED3\u6E05\u5355 ${manifestPath2} repos=${entries.map((e) => `${e.path}\u2192${e.remoteUrl}`).join(", ")}`
+      `[apm] \u4EFB\u52A1\u5206\u652F ${branch} @ ${label} (project baseline=${baselineBranch})`
     );
-    return roots2;
+    await ensureFeatureBranch(branch, baselineBranch, {
+      ...options,
+      cwd: gitRoot
+    });
   }
-  const workspace = loadWorkspaceReposCache(workdirPath);
-  const roots = resolveWorkspaceRepoAbsolutePaths(workspace);
-  console.log(
-    `[apm] \u8BFB\u53D6\u5DE5\u4F5C\u533A\u4ED3\u5E93\u6E05\u5355 repos=${workspace.repos.map(
-      (r) => r.remoteUrl ? `${r.path}\u2192${r.remoteUrl}` : r.path
-    ).join(", ")}`
-  );
-  return roots;
+  return {
+    branch,
+    baseline: baselineBranch,
+    kind: manifest.kind,
+    repos: repoRoots
+  };
 }
-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");
+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");
   }
   const cwd = options.cwd ?? process.cwd();
   const workdirPath = resolveWorkdirPath(cwd);
-  const repoRoots = resolveTaskBranchRepoRoots(
-    workdirPath,
-    options.reposManifest
-  );
-  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(",")}`
-  );
+  const manifest = loadWorkspaceReposCache(workdirPath);
+  const repoRoots = resolveWorkspaceRepoAbsolutePaths(manifest);
   for (const gitRoot of repoRoots) {
     const label = formatRepoLabel(workdirPath, 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}`
-      );
-    }
+    console.log(`[apm] \u5207\u6362\u57FA\u7EBF\u5206\u652F ${baseline} @ ${label}`);
+    await checkoutBaselineBranch(baseline, { ...options, cwd: gitRoot });
   }
   return {
-    branch,
-    projectId: trimmedProjectId,
-    kind: "multi",
+    baseline,
+    kind: manifest.kind,
     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 {
@@ -1690,8 +1631,8 @@ function createUpsertWebIdeTestCasesTool(options) {
 }
 
 // src/commands/connect/tools/mysql-tools.ts
-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 { existsSync as existsSync3, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
+import { isAbsolute, relative as relative2, resolve as resolve4 } from "node:path";
 import mysql from "mysql2/promise";
 var MAX_RESULT_ROWS = 100;
 var EXEC_TIMEOUT_MS = 6e4;
@@ -1762,14 +1703,14 @@ function resolveSqlArtifactPath(workdir, absolutePath) {
   if (!isAbsolute(absolutePath)) {
     return { ok: false, error: "path \u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84" };
   }
-  const workdirAbs = resolve5(toFsPath(workdir));
-  const targetAbs = resolve5(toFsPath(absolutePath));
+  const workdirAbs = resolve4(toFsPath(workdir));
+  const targetAbs = resolve4(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 (!existsSync4(fsPath)) {
+  if (!existsSync3(fsPath)) {
     return { ok: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${absolutePath}` };
   }
   let st;
@@ -1791,7 +1732,7 @@ function resolveSqlArtifactPath(workdir, absolutePath) {
   return { ok: true, absPath: targetAbs, displayPath };
 }
 function readSqlFile(absPath) {
-  return readFileSync4(toFsPath(absPath), "utf8");
+  return readFileSync3(toFsPath(absPath), "utf8");
 }
 function createMysqlExecuteTool(options) {
   const { taskId, executionId, workdir, upsertSqlExecution } = options;
@@ -1969,1211 +1910,2371 @@ function createMysqlExecuteTool(options) {
   };
 }
 
-// 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);
+// 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
+    });
   }
-  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)
-        })
-      );
+  async ensureBucket(bucket) {
+    const exists = await this.inner.bucketExists(bucket);
+    if (!exists) {
+      await this.inner.makeBucket(bucket);
     }
   }
-  return tools;
-}
-function withPlanModeToolHint(prompt, mode) {
-  if (mode !== "plan") {
-    return prompt;
+  async putObject(bucket, objectKey, body, meta) {
+    await this.inner.putObject(bucket, objectKey, body, body.length, meta);
   }
-  return `${prompt.trim()}
+  /** 大文件：从本地路径流式上传，避免整包读入内存 */
+  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));
+    }
+    return Buffer.concat(chunks);
+  }
+};
 
-${PLAN_MODE_ASK_QUESTION_HINT}`;
+// src/commands/connect/apm-log-minio.ts
+async function fetchApmLogStorage(cfg2) {
+  const api = createApmApiClient(cfg2);
+  return api.cli.getApmLogStorage(void 0);
 }
-function withWorkspaceBoundaryHint(prompt) {
-  return `${prompt.trim()}
-
-${WORKSPACE_BOUNDARY_HINT}`;
+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 } : {}
+  };
 }
 
-// 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
-  };
+// 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");
 }
-function toApiCheckpointRef(ref) {
-  if (ref === void 0) return void 0;
-  if (ref === null) return null;
-  return {
-    schemaVersion: ref.schemaVersion,
-    rootBlobId: ref.rootBlobId
-  };
+function sha256File(absPath) {
+  const hash = createHash("sha256");
+  hash.update(fs.readFileSync(absPath));
+  return hash.digest("hex");
 }
-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 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}`);
+  }
+  return trimmed;
+}
+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)
+      });
+    }
   };
+  walk(root);
+  return [...byRelative.values()].sort(
+    (a, b) => a.relativePath.localeCompare(b.relativePath)
+  );
 }
-function fromApiRun(row) {
+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;
+  }
   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
+    scanned: localFiles.length,
+    uploaded,
+    skipped,
+    deleted
   };
 }
-var unsupportedCheckpoints = {
-  async get() {
-    return null;
-  },
-  async create() {
-  },
-  async update() {
-  },
-  async delete() {
-  },
-  async list() {
-    return { items: [] };
+
+// src/commands/connect/tools/package-sql-tool.ts
+function asString4(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function resolveLocalSqlDir(workdir, localDirArg) {
+  if (!isAbsolute2(localDirArg)) {
+    return { ok: false, error: "localDir \u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84" };
   }
-};
-var unsupportedRunEvents = {
-  async append() {
-    throw new Error("runEvents \u4EC5\u5B58\u672C\u673A SQLite");
-  },
-  async list() {
-    return { items: [] };
-  },
-  async delete() {
+  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" };
   }
-};
-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);
+  const fsPath = toFsPath(targetAbs);
+  if (!existsSync4(fsPath)) {
+    return { ok: false, error: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${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);
+  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}` };
   }
+  return { ok: true, absPath: targetAbs };
+}
+function createUploadPackageSqlTool(options) {
+  const { cfg: cfg2, workdir, projectId } = options;
   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);
+    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"]
       },
-      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;
+      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
+          };
         }
-        if (cwd) {
-          await api.cli.cursorStoreDeleteAgents({ cwd });
-          return;
+        if (!localDirRaw) {
+          return {
+            content: [{ type: "text", text: "localDir \u4E0D\u80FD\u4E3A\u7A7A" }],
+            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;
+        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
+          };
         }
-      },
-      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;
+        const resolved = resolveLocalSqlDir(workdir, localDirRaw);
+        if (!resolved.ok) {
+          return {
+            content: [{ type: "text", text: resolved.error }],
+            isError: true
+          };
         }
-        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)
+        try {
+          const result = await syncPackageSqlToMinio({
+            cfg: cfg2,
+            projectId,
+            repo,
+            localDir: resolved.absPath
           });
-          if (!page.nextCursor) break;
-          cursor = page.nextCursor;
+          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
+          };
         }
-      },
-      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);
+// src/commands/connect/tools/package-status-tool.ts
+function createSetPackageFailedTool(options) {
+  const { packageId, setFailed } = options;
   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
-        );
+    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
+          };
+        }
       }
     }
   };
 }
-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)
-  });
-}
-
-// 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}`;
+// 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 `Cursor run \u5931\u8D25: ${runId} \u2014 ${details.join("\uFF1B")}`;
+  return legacyDefault;
 }
-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 } : {}
+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
+    }) : {}
   };
-  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
+  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 })
+        })
       );
-      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 });
+    if (wantsTool("UpsertWebIdePlan", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createUpsertWebIdePlanTool({
+          webideUpsertPlan: (args) => cli.webideUpsertPlan({ taskId, ...args })
+        })
+      );
     }
-    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
-  });
-  const enableSandbox = Boolean(options.enableSandbox);
-  let prompt = withPlanModeToolHint(ctx.prompt, ctx.mode);
-  prompt = withWorkspaceBoundaryHint(prompt);
-  console.log(
-    `[apm] Cursor Agent \u5F00\u59CB messageId=${ctx.messageId} 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,
-    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);
+    if (wantsTool("UpsertWebIdeChecklist", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createUpsertWebIdeChecklistTool({
+          webideUpsertChecklist: (args) => cli.webideUpsertChecklist({ taskId, ...args })
+        })
+      );
     }
-    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 (wantsTool("GetWebIdeChecklist", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createGetWebIdeChecklistTool({
+          boundTaskId: taskId,
+          webideGetChecklist: (args) => cli.webideGetChecklist(args)
+        })
       );
     }
-    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 (wantsTool("UpsertWebIdeTestCases", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createUpsertWebIdeTestCasesTool({
+          webideReplaceTestCases: (args) => cli.webideReplaceTestCases({ taskId, ...args })
+        })
+      );
     }
-    if (result.status === "cancelled") {
-      throw new Error(`Cursor run \u5DF2\u53D6\u6D88: ${result.id}`);
+    if (wantsTool("MergeWebIdePullRequests", options, enablePlan)) {
+      Object.assign(
+        tools,
+        createMergeWebIdePullRequestsTool({
+          webideMergePullRequests: () => cli.webideMergePullRequests({ taskId })
+        })
+      );
     }
-    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
-        );
-      }
+    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 {
-      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" : ""}`
+  }
+  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
+        })
       );
     }
-    throw err;
-  } finally {
-    clearRunSteer();
-    signal?.removeEventListener("abort", abortRun);
-    await agent[Symbol.asyncDispose]();
   }
+  return tools;
 }
+function withPlanModeToolHint(prompt, mode) {
+  if (mode !== "plan") {
+    return prompt;
+  }
+  return `${prompt.trim()}
 
-// 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);
+${PLAN_MODE_ASK_QUESTION_HINT}`;
 }
-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();
+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}`
       }
-      return state;
     }
-  } catch {
+  };
+}
+
+// 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 {};
+  return {
+    schemaVersion: 1,
+    rootBlobId: row.rootBlobId
+  };
 }
-function writeRegistry(path, registry) {
-  mkdirSync4(dirname3(path), { recursive: true });
-  writeFileSync3(path, `${JSON.stringify(registry, null, 2)}
-`, "utf8");
+function toApiCheckpointRef(ref) {
+  if (ref === void 0) return void 0;
+  if (ref === null) return null;
+  return {
+    schemaVersion: ref.schemaVersion,
+    rootBlobId: ref.rootBlobId
+  };
 }
-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()
+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
+      );
+      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);
+    }
+  };
+}
+
+// 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}
+`;
+}
+function readRevision(apmDir) {
+  const path3 = toFsPath(join4(apmDir, REVISION_FILE));
+  if (!existsSync5(path3)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync4(path3, "utf8"));
+    if (parsed?.version === 1 && parsed.revision?.trim()) {
+      return parsed.revision.trim();
+    }
+  } 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) {
+  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
+  };
+}
+
+// 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;
+  }
+}
+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();
+}
+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);
+    }
+  }
+  return { download, deleteLocal };
+}
+async function resolveProjectIdForSync(api, workdirPath, options) {
+  const explicit = options?.projectId?.trim();
+  if (explicit) {
+    return { projectId: explicit, diagnostic: null };
+  }
+  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*/, "")
+    };
+  }
+}
+async function syncProjectDocumentsPull(workdirPath, apmDir, options) {
+  const empty = {
+    synced: false,
+    projectId: null,
+    downloaded: 0,
+    deleted: 0
   };
-  if (patch.agentId !== void 0) {
-    const agentId = patch.agentId.trim();
-    if (agentId) next.agentId = agentId;
-    else delete next.agentId;
+  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;
   }
-  if (patch.messageId !== void 0) {
-    const messageId = patch.messageId.trim();
-    if (messageId) next.messageId = messageId;
-    else delete next.messageId;
+  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)
+      );
+      await ensureDirExists(dirname2(absPath));
+      writeFileSync4(absPath, doc.content, "utf8");
+      downloaded += 1;
+    }
   }
-  if (patch.action !== void 0) {
-    const action = patch.action.trim();
-    if (action) next.action = action;
-    else delete next.action;
+  let deleted = 0;
+  for (const path3 of deleteLocal) {
+    const absPath = toFsPath(
+      projectDocumentLocalPath(targetApmDir, projectId, path3)
+    );
+    if (existsSync6(absPath)) {
+      rmSync(absPath, { force: true });
+      deleted += 1;
+    }
   }
-  if (patch.status !== void 0) {
-    next.status = patch.status;
+  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;
+    }
+    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 });
+  } catch (err) {
+    console.warn(
+      `[apm] \u6E05\u7406\u6253\u5305\u4E34\u65F6\u76EE\u5F55\u5931\u8D25 ${dir}:`,
+      err instanceof Error ? err.message : 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}`);
+  }
+  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 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 } : {}
+  });
+}
+async function handleWebIdePackage(cfg2, msg2, signal) {
+  const workdir = requireRemoteWorkdir(msg2.workdir);
+  const messageId = msg2.messageId;
+  const packageId = msg2.packageId;
+  const projectId = msg2.projectId;
+  console.log(
+    `[apm] webide-package target=${msg2.target} packageId=${packageId} projectId=${projectId} baseBranch=${msg2.baseBranch}`
+  );
+  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}`;
+      }
+    );
+    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"
+          );
+          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
+      });
+      await logSyncRef.current?.markRun(
+        outcome.runId,
+        "error",
+        detail,
+        tokenUsage
+      );
+      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"
+      });
+      return;
+    }
+    await logSyncRef.current?.markRun(
+      outcome.runId,
+      "finished",
+      null,
+      tokenUsage
+    );
+    if (failedByTool) {
+      console.log(
+        `[apm] webide-package Agent \u5DF2\u6807 FAILED packageId=${packageId}`
+      );
+      return;
+    }
+    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}`
+    );
+  } 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 });
+      }
+    } catch (statusErr) {
+      console.error(
+        "[apm] \u5199\u5165\u6253\u5305 FAILED \u5931\u8D25:",
+        statusErr instanceof Error ? statusErr.message : statusErr
+      );
+    }
   }
-  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/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`);
+// 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;
     }
-    questions.push({ id, prompt, options });
   }
-  if (questions.length === 0) {
-    throw new Error("AskQuestion \u65E0\u6709\u6548\u95EE\u9898");
-  }
-  return { title, questions };
+  return DEFAULT_REPLY;
 }
-async function fetchAssumptionAnswersAndContinueAssessment(options) {
-  const { cfg: cfg2, taskId, questionIds, title } = options;
+
+// src/commands/connect/core/worker/handlers/start-project.ts
+async function updateStatus(cfg2, messageId, status) {
   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 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
-    });
-  }
+  await api.cli.webideUpdateMessageStatus({ id: messageId, status });
+}
+async function setError(cfg2, messageId, error) {
+  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;
   console.log(
-    `[apm] \u5047\u8BBE\u7ED3\u679C\u5DF2\u62C9\u53D6 taskId=${taskId} count=${answers.length}`
+    `[apm] webide-start-project target=${msg2.target} restart=${msg2.restart} taskId=${taskId} messageId=${messageId}`
   );
-  return JSON.stringify({ title, answers }, null, 2);
-}
-function createWebIdeAskQuestionExecute(options) {
-  const { cfg: cfg2, taskId, onAwaitingAssumptions } = options;
-  return async (args) => {
-    const parsed = parseQuestions(args);
+  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);
     const api = createApmApiClient(cfg2);
-    console.log(
-      `[apm] AskQuestion \u521B\u5EFA\u5F85\u786E\u8BA4\u9879 taskId=${taskId} count=${parsed.questions.length}`
+    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);
+        }
+      }
     );
-    await api.cli.webideReplaceAssumptions({
-      taskId,
-      title: parsed.title,
-      questions: parsed.questions
-    });
-    await api.cli.webideRunAction({
-      taskId,
-      action: "await-assumptions"
+    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
     });
-    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
+    await api.cli.webideEnsureMessageContent({
+      id: messageId,
+      content: fallback
     });
-  }
-  async ensureBucket(bucket) {
-    const exists = await this.inner.bucketExists(bucket);
-    if (!exists) {
-      await this.inner.makeBucket(bucket);
+    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
+      );
     }
   }
-  async putObject(bucket, objectKey, body, meta) {
-    await this.inner.putObject(bucket, objectKey, body, body.length, meta);
+}
+
+// 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 fPutObject(bucket, objectKey, filePath, meta) {
-    await this.inner.fPutObject(bucket, objectKey, filePath, 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 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;
+  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 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.messageId !== void 0) {
+    const messageId = patch.messageId.trim();
+    if (messageId) next.messageId = messageId;
+    else delete next.messageId;
   }
-  async removeObject(bucket, objectKey) {
-    await this.inner.removeObject(bucket, objectKey);
+  if (patch.action !== void 0) {
+    const action = patch.action.trim();
+    if (action) next.action = action;
+    else delete next.action;
   }
-  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);
+  if (patch.status !== void 0) {
+    next.status = patch.status;
   }
-};
-
-// src/commands/connect/apm-log-minio.ts
-async function fetchApmLogStorage(cfg2) {
-  const api = createApmApiClient(cfg2);
-  return api.cli.getApmLogStorage(void 0);
+  writeRegistry(path3, next);
 }
-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 loadWebIdeAgentId(workdir, taskId) {
+  return readRegistry(registryPath(workdir, taskId)).agentId;
 }
-
-// src/commands/connect/webide-message-log.ts
-var SYNC_INTERVAL_MS = 2e3;
-function webIdeEventsObjectPrefix(taskId, messageId) {
-  return `events/webide/${taskId}/${messageId}/`;
+function saveWebIdeAgentId(workdir, taskId, agentId) {
+  syncWebIdeTaskState(workdir, taskId, { agentId });
 }
-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 clearWebIdeAgentId(workdir, taskId) {
+  const path3 = registryPath(workdir, taskId);
+  if (!existsSync7(path3)) return;
+  syncWebIdeTaskState(workdir, taskId, { agentId: "" });
 }
-async function upsertLogHeader(cfg2, ctx, patch, objectPrefix) {
-  const api = createApmApiClient(cfg2);
-  await api.cli.webideUpsertMessageLog({
-    messageId: ctx.messageId,
-    agentId: ctx.agentId,
-    objectPrefix,
-    ...patch
-  });
+function loadWebIdeDesignAgentId(workdir, taskId) {
+  return readRegistry(registryPath(workdir, taskId, DESIGN_AGENT_FILE)).agentId;
 }
-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;
-      }
-      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);
-    }
-  };
+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()
+  });
+}
+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()
+  });
 }
 
-// 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/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
+      }
+    });
+    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
+    });
   }
-  return DEFAULT_REPLY;
-}
-
-// 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 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();
+  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
+      );
     }
-  } catch {
-    return null;
   }
-  return null;
-}
-function writeRevision(apmDir, revision) {
-  writeFileSync4(
-    toFsPath(join6(apmDir, REVISION_FILE)),
-    `${JSON.stringify({ version: 1, revision }, null, 2)}
-`,
-    "utf8"
-  );
+  return true;
 }
-async function syncWebIdeAgentFiles(workdir, cfg2) {
-  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);
-  mkdirSync5(toFsPath(apmDir), { recursive: true });
-  if (readRevision(apmDir) === revision) {
-    return { revision, wrote: false, ruleCount: bundle.rules?.length ?? 0 };
+async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
+  const trimmedTaskId = taskId.trim();
+  const trimmedWorkdir = workdir.trim();
+  if (!trimmedTaskId || !trimmedWorkdir) {
+    return;
   }
-  const rulesDir = join6(apmDir, "rules");
-  mkdirSync5(toFsPath(rulesDir), { recursive: true });
-  writeFileSync4(
-    toFsPath(join6(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)"}`);
+  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
+      );
     }
-    keep.add(`${key}.md`);
-    writeFileSync4(
-      toFsPath(join6(rulesDir, `${key}.md`)),
-      withTrailingNewline(rule.body ?? ""),
-      "utf8"
+  } else {
+    console.log(
+      `[apm] \u65E0 WebIDE agentId\uFF0C\u8DF3\u8FC7 agent store \u6E05\u7406 taskId=${trimmedTaskId}`
     );
   }
-  for (const name of readdirSync3(toFsPath(rulesDir))) {
-    if (!name.endsWith(".md")) continue;
-    if (keep.has(name)) continue;
-    unlinkSync(toFsPath(join6(rulesDir, name)));
+  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}`);
   }
-  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 };
+// src/commands/connect/webide-ask-question.ts
+function asString5(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+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`);
+    }
+    questions.push({ id, prompt, options });
+  }
+  if (questions.length === 0) {
+    throw new Error("AskQuestion \u65E0\u6709\u6548\u95EE\u9898");
+  }
+  return { title, questions };
+}
+async function fetchAssumptionAnswersAndContinueAssessment(options) {
+  const { cfg: cfg2, taskId, questionIds, title } = options;
+  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 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] \u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u672A\u68C0\u6D4B\u5230\u5DF2\u521D\u59CB\u5316\u7684 .apm\uFF0C\u6B63\u5728\u6309 WebIDE \u81EA\u52A8\u521D\u59CB\u5316\u2026`
+    `[apm] \u5047\u8BBE\u7ED3\u679C\u5DF2\u62C9\u53D6 taskId=${taskId} count=${answers.length}`
   );
-  await ensureWorkspaceApmDirForInit(workdir);
-  console.log(`[apm] \u5DF2\u521B\u5EFA\u5DE5\u4F5C\u533A\u76EE\u5F55\uFF1A${workspaceApmDir(workdir)}`);
-  return { didInit: true };
+  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}`
+    );
+    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("");
+  };
 }
 
 // src/commands/connect/pre-step-cache.ts
@@ -3400,9 +4501,9 @@ async function ensureWebIdePullRequests(cfg2, taskId, workdir) {
 }
 
 // src/commands/sync-webide-attachments.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
-import { join as join7 } from "path";
-var MANIFEST_FILE = ".sync-manifest.json";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join6 } from "path";
+var MANIFEST_FILE2 = ".sync-manifest.json";
 async function downloadAttachment(cfg2, attachmentId) {
   const base = cfg2.baseUrl.trim().replace(/\/+$/, "");
   const url = `${base}/api/v1/tasks/attachments/file?${new URLSearchParams({
@@ -3417,13 +4518,13 @@ async function downloadAttachment(cfg2, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path = join7(dir, MANIFEST_FILE);
-  if (!existsSync7(path)) {
+  const path3 = join6(dir, MANIFEST_FILE2);
+  if (!existsSync9(path3)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync7(path, "utf8")
+      readFileSync7(path3, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -3433,15 +4534,15 @@ function loadManifest(dir) {
   return { version: 1, attachments: {} };
 }
 function saveManifest(dir, manifest) {
-  writeFileSync5(
-    join7(dir, MANIFEST_FILE),
+  writeFileSync6(
+    join6(dir, MANIFEST_FILE2),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
 function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync7(dest)) return false;
+  if (!entry || !existsSync9(dest)) return false;
   if (entry.name !== item.name) return false;
   const createdAt = item.createdAt ?? "";
   return entry.createdAt === createdAt;
@@ -3456,7 +4557,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
   const nextManifest = { version: 1, attachments: {} };
   const names = [];
   for (const item of attachments) {
-    const dest = join7(dir, item.name);
+    const dest = join6(dir, item.name);
     const entry = manifest.attachments[item.id];
     const createdAt = item.createdAt ?? "";
     names.push(item.name);
@@ -3466,7 +4567,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
       continue;
     }
     const buffer = await downloadAttachment(cfg2, item.id);
-    writeFileSync5(dest, buffer);
+    writeFileSync6(dest, buffer);
     nextManifest.attachments[item.id] = {
       name: item.name,
       createdAt
@@ -3487,9 +4588,9 @@ async function syncWebIdeAttachments(cfg2, taskId, workdir, attachments) {
 }
 
 // src/commands/sync-webide-design.ts
-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";
+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";
 
 // src/opc-shared-types.ts
 function webIdeDesignObjectKey(taskId, fileName) {
@@ -3505,17 +4606,17 @@ function webIdeDesignArtifactContentType(name) {
 }
 
 // src/commands/sync-webide-design.ts
-var MANIFEST_FILE2 = ".sync-manifest.json";
+var MANIFEST_FILE3 = ".sync-manifest.json";
 function hashBuffer(buf) {
-  return createHash("sha256").update(buf).digest("hex");
+  return createHash3("sha256").update(buf).digest("hex");
 }
 function loadManifest2(dir) {
-  const path = join8(dir, MANIFEST_FILE2);
-  if (!existsSync8(path)) {
+  const path3 = join7(dir, MANIFEST_FILE3);
+  if (!existsSync10(path3)) {
     return { version: 1, files: {} };
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path3, "utf8"));
     if (parsed?.version === 1 && parsed.files && typeof parsed.files === "object") {
       return parsed;
     }
@@ -3524,8 +4625,8 @@ function loadManifest2(dir) {
   return { version: 1, files: {} };
 }
 function saveManifest2(dir, manifest) {
-  writeFileSync6(
-    join8(dir, MANIFEST_FILE2),
+  writeFileSync7(
+    join7(dir, MANIFEST_FILE3),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
@@ -3553,13 +4654,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 = join8(dir, name);
+    const localPath = join7(dir, name);
     const entry = manifest.files[name];
-    if (entry?.contentHash === art.contentHash && existsSync8(localPath)) {
+    if (entry?.contentHash === art.contentHash && existsSync10(localPath)) {
       continue;
     }
     const buf = await downloadDesignFile(cfg2, taskId, name);
-    writeFileSync6(localPath, buf);
+    writeFileSync7(localPath, buf);
     manifest.files[name] = { contentHash: hashBuffer(buf) };
     synced.push(name);
   }
@@ -3568,12 +4669,12 @@ async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
 }
 function listLocalDesignArtifactFiles(taskId, workdir) {
   const dir = webideDesignDir(taskId, workdir);
-  if (!existsSync8(dir)) return [];
+  if (!existsSync10(dir)) return [];
   const out = [];
-  for (const name of readdirSync4(dir)) {
+  for (const name of readdirSync5(dir)) {
     if (!isWebIdeDesignArtifactName(name)) continue;
-    const absPath = join8(dir, name);
-    if (!statSync4(absPath).isFile()) continue;
+    const absPath = join7(dir, name);
+    if (!statSync5(absPath).isFile()) continue;
     const buf = readFileSync8(absPath);
     if (buf.length === 0) continue;
     out.push({ name, absPath, contentHash: hashBuffer(buf) });
@@ -3658,6 +4759,8 @@ 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":
@@ -3692,6 +4795,9 @@ 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";
@@ -3763,6 +4869,9 @@ 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";
 }
@@ -3773,11 +4882,11 @@ function syncLocalTaskStatus(workdir, taskId, msg2, status) {
     status
   });
 }
-async function updateStatus(cfg2, messageId, status) {
+async function updateStatus2(cfg2, messageId, status) {
   const api = createApmApiClient(cfg2);
   await api.cli.webideUpdateMessageStatus({ id: messageId, status });
 }
-async function setError(cfg2, messageId, error) {
+async function setError2(cfg2, messageId, error) {
   const api = createApmApiClient(cfg2);
   await api.cli.webideSetMessageError({ id: messageId, error });
 }
@@ -3796,7 +4905,7 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
   console.log(
     `[apm] webide-message action=${msg2.action}${previousAction ? ` previousAction=${previousAction}` : ""} taskId=${taskId} messageId=${messageId}`
   );
-  await updateStatus(cfg2, messageId, "TYPING");
+  await updateStatus2(cfg2, messageId, "TYPING");
   syncLocalTaskStatus(workdir, taskId, msg2, "TYPING");
   const eventSession = new EventSession(msg2.content);
   const prepAgentId = loadWebIdeAgentId(workdir, taskId) ?? "webide-cli-prep";
@@ -3887,13 +4996,10 @@ 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 () => {
-          const projectId = await resolveProjectIdForTask(taskId);
-          return runTaskBranch(taskId, projectId, { cwd: workdir });
-        },
+        async () => runTaskBranch(taskId, { cwd: workdir }),
         (branchResult) => {
           markBranchDone(branchCacheKey, workdir);
-          return `kind=${branchResult.kind} branch=${branchResult.branch} projectId=${branchResult.projectId} repos=${branchResult.repos.length}`;
+          return `kind=${branchResult.kind} branch=${branchResult.branch} baseline=${branchResult.baseline} repos=${branchResult.repos.length}`;
         }
       );
     } else {
@@ -3919,6 +5025,43 @@ 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 () => {
@@ -3969,17 +5112,18 @@ 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) {
+    if (useNewAgent && !startLocalServices) {
       if (designAction) {
         clearWebIdeDesignAgentId(workdir, taskId);
       } else {
         clearWebIdeAgentId(workdir, taskId);
       }
     }
-    const savedAgentId = useNewAgent ? void 0 : designAction ? loadWebIdeDesignAgentId(workdir, taskId) : loadWebIdeAgentId(workdir, taskId);
+    const savedAgentId = startLocalServices || 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) {
@@ -3988,6 +5132,7 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
       );
     }
     const persistAgentId = (agentId) => {
+      if (startLocalServices) return;
       if (designAction) {
         saveWebIdeDesignAgentId(workdir, taskId, agentId);
       } else {
@@ -4013,7 +5158,7 @@ ${assumptionAnswersText}` : msg2.content,
         forceSend: true,
         eventSession,
         appendMessageContent: (content) => appendContent(cfg2, messageId, content),
-        askQuestionExecute: toolNames.includes("AskQuestion") ? createWebIdeAskQuestionExecute({
+        askQuestionExecute: !startLocalServices && toolNames.includes("AskQuestion") ? createWebIdeAskQuestionExecute({
           cfg: cfg2,
           taskId,
           onAwaitingAssumptions: () => {
@@ -4025,10 +5170,11 @@ ${assumptionAnswersText}` : msg2.content,
         enableAskQuestion: false,
         enableWebIdePlanTools: false,
         enableMysqlTools: false,
+        enablePtySessionMcp: startLocalServices || toolNames.includes("PtySession"),
         sqlExecutionId,
         toolNames,
         enableSandbox: false,
-        onInvalidatePersistedAgentId: () => {
+        onInvalidatePersistedAgentId: startLocalServices ? void 0 : () => {
           if (designAction) {
             clearWebIdeDesignAgentId(workdir, taskId);
           } else {
@@ -4081,7 +5227,9 @@ ${assumptionAnswersText}` : msg2.content,
         }
       }
     );
-    persistAgentId(outcome.agentId);
+    if (!startLocalServices) {
+      persistAgentId(outcome.agentId);
+    }
     const tokenUsage = outcome.usage != null ? {
       modelId: outcome.modelId ?? (msg2.model?.trim() || void 0),
       inputTokens: outcome.usage.inputTokens,
@@ -4115,7 +5263,7 @@ ${assumptionAnswersText}` : msg2.content,
           );
         }
       }
-      await setError(cfg2, messageId, detail);
+      await setError2(cfg2, messageId, detail);
       syncLocalTaskStatus(workdir, taskId, msg2, "FAILED");
       return;
     }
@@ -4140,7 +5288,7 @@ ${assumptionAnswersText}` : msg2.content,
           );
         }
       }
-      await updateStatus(cfg2, messageId, "CANCELLED");
+      await updateStatus2(cfg2, messageId, "CANCELLED");
       syncLocalTaskStatus(workdir, taskId, msg2, "CANCELLED");
       return;
     }
@@ -4185,7 +5333,7 @@ ${assumptionAnswersText}` : msg2.content,
           detail,
           tokenUsage
         );
-        await setError(cfg2, messageId, detail);
+        await setError2(cfg2, messageId, detail);
         syncLocalTaskStatus(workdir, taskId, msg2, "FAILED");
         return;
       }
@@ -4262,6 +5410,16 @@ ${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",
@@ -4276,11 +5434,21 @@ ${assumptionAnswersText}` : msg2.content,
         `[apm] \u672C\u8F6E\u505C\u5728\u5F85\u786E\u8BA4\u5047\u8BBE\uFF0C\u8DF3\u8FC7 complete action=${effectiveAction} taskId=${taskId}`
       );
     }
-    await updateStatus(cfg2, messageId, "SUCCESS");
+    await updateStatus2(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}`);
@@ -4291,7 +5459,7 @@ ${assumptionAnswersText}` : msg2.content,
       clearWebIdeAgentId(workdir, taskId);
     }
     try {
-      await setError(cfg2, messageId, detail);
+      await setError2(cfg2, messageId, detail);
     } catch (statusErr) {
       console.error(
         "[apm] \u5199\u5165 WebIDE FAILED \u5931\u8D25:",
@@ -4315,7 +5483,23 @@ ${assumptionAnswersText}` : msg2.content,
 
 // src/commands/connect/core/worker/handlers/index.ts
 async function dispatchWorkerJob(cfg2, msg2, signal) {
-  await handleWebIdeInboundMessage(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"}`
+      );
+    }
+  }
 }
 
 // src/commands/connect/core/worker/worker-script.ts