ai-project-manage-cli 8.0.1 → 8.0.3

package/dist/webide-message-worker.js

@@ -1,5 +1,5 @@
 // src/commands/connect/webide-message-worker.ts
-import { parentPort as parentPort2, workerData } from "node:worker_threads";
+import { parentPort, workerData } from "node:worker_threads";
 
 // src/api/client.ts
 import { createApiClient } from "listpage-http";
@@ -58,36 +58,12 @@ var requestConfig = {
       method: "PUT",
       path: "/cli/webide/test-cases"
     }),
-    webideListTerminals: defineEndpoint({
-      method: "GET",
-      path: "/cli/webide/terminals"
-    }),
-    webideUpsertTerminal: defineEndpoint({
-      method: "POST",
-      path: "/cli/webide/terminals"
-    }),
-    webideUpdateTerminalStatus: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/terminals/status"
-    }),
-    webideUpdateTerminalMeta: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/terminals/meta"
-    }),
     projectBaseBranch: defineEndpoint(
       {
         method: "GET",
         path: "/cli/tasks/project-base-branch"
       }
     ),
-    workspaceBaseline: defineEndpoint({
-      method: "GET",
-      path: "/cli/workspaces/baseline"
-    }),
-    matchRepository: defineEndpoint({
-      method: "GET",
-      path: "/cli/repositories/match"
-    }),
     createWebIdeDraftPullRequest: defineEndpoint({
       method: "POST",
       path: "/cli/webide/draft-pull-requests"
@@ -112,35 +88,9 @@ var requestConfig = {
       method: "DELETE",
       path: "/cli/project-documents"
     }),
-    createTaskDeployment: defineEndpoint({
-      method: "POST",
-      path: "/cli/task-deployments"
-    }),
-    updateTaskDeploymentStatus: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/status"
-    }),
-    syncTaskDeploymentLog: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/log"
-    }),
-    completeTaskDeployment: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/complete"
-    }),
-    getDeployArtifactStorage: defineEndpoint(
-      {
-        method: "GET",
-        path: "/cli/deploy-artifact-storage"
-      }
-    ),
     getApmLogStorage: defineEndpoint({
       method: "GET",
       path: "/cli/apm-log-storage"
-    }),
-    attachTaskDeploymentArtifact: defineEndpoint({
-      method: "PUT",
-      path: "/cli/task-deployments/artifact"
     })
   }
 };
@@ -221,7 +171,7 @@ function createApmApiClient(cfg) {
   });
 }
 
-// src/workdir-path.ts
+// src/utils/path.ts
 import { realpathSync } from "fs";
 import { platform } from "os";
 import { resolve } from "path";
@@ -268,7 +218,7 @@ function requireRemoteWorkdir(workdir) {
   return resolveWorkdirPath(trimmed);
 }
 
-// src/command-utils.ts
+// src/utils/workspace.ts
 import { copyFileSync, existsSync, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
 import { dirname, join as join2, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
@@ -405,11 +355,11 @@ async function copyWebIdeTemplateFiles(targetDir, workdir = resolveWorkdirPath()
   assertWebIdeTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
 }
 
-// src/git-utils.ts
+// src/utils/git.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 
-// src/git-remote.ts
+// src/utils/git-remote.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -462,7 +412,7 @@ async function tryReadHttpsGitOriginUrl(cwd) {
   return toHttpsGitRemoteUrl(raw);
 }
 
-// src/git-utils.ts
+// src/utils/git.ts
 var execFileAsync2 = promisify2(execFile2);
 function gitExecEnv() {
   const existing = process.env.GIT_SSH_COMMAND?.trim();
@@ -560,90 +510,15 @@ async function branchHasChangesAgainstBase(cwd, baseBranch, headBranch) {
     return true;
   }
 }
-var FEATURE_BRANCH_RE = /^feat\/task-.+/;
+var FEATURE_BRANCH_RE = /^feat\/task-(.+)$/;
 function isFeatureBranchName(branch) {
   return FEATURE_BRANCH_RE.test(branch.trim().replace(/^origin\//, ""));
 }
-async function resolveFeatureBranchBaseFromGit(cwd, headBranch) {
-  const head = headBranch.trim().replace(/^origin\//, "");
-  if (!head) {
-    throw new Error("[apm] head \u5206\u652F\u540D\u4E3A\u7A7A\uFF0C\u65E0\u6CD5\u63A8\u65AD\u57FA\u7EBF");
-  }
-  try {
-    const reflog = await execGit(
-      cwd,
-      ["reflog", "show", "--date=iso", head],
-      true
-    );
-    for (const line of reflog.split("\n")) {
-      const created = line.match(
-        /Created from (?:refs\/remotes\/origin\/|origin\/)?(\S+)/i
-      );
-      if (created?.[1]) {
-        const name = created[1].replace(/^origin\//, "");
-        if (name && name !== head && !isFeatureBranchName(name)) {
-          return name;
-        }
-      }
-      const moving = line.match(
-        /checkout: moving from (\S+) to (?:origin\/)?\S+/i
-      );
-      if (moving?.[1]) {
-        const from = moving[1].replace(/^origin\//, "");
-        if (from && from !== head && !isFeatureBranchName(from)) {
-          return from;
-        }
-      }
-    }
-  } catch {
-  }
-  await execGit(cwd, ["fetch", "origin", "--prune"], true);
-  let headRef = head;
-  try {
-    await execGit(cwd, ["rev-parse", "--verify", `origin/${head}`], true);
-    headRef = `origin/${head}`;
-  } catch {
-    await execGit(cwd, ["rev-parse", "--verify", head], true);
-  }
-  const refsOut = await execGit(
-    cwd,
-    ["for-each-ref", "--format=%(refname:short)", "refs/remotes/origin/"],
-    true
-  );
-  let best = null;
-  for (const ref of refsOut.split("\n").map((s) => s.trim()).filter(Boolean)) {
-    const name = ref.replace(/^origin\//, "");
-    if (!name || name === "HEAD" || name === head || isFeatureBranchName(name)) {
-      continue;
-    }
-    try {
-      await execGit(
-        cwd,
-        ["merge-base", "--is-ancestor", `origin/${name}`, headRef],
-        true
-      );
-      const ahead = Number.parseInt(
-        (await execGit(
-          cwd,
-          ["rev-list", "--count", `origin/${name}..${headRef}`],
-          true
-        )).trim(),
-        10
-      );
-      if (!Number.isFinite(ahead) || ahead < 0) continue;
-      if (!best || ahead < best.ahead) {
-        best = { name, ahead };
-      }
-    } catch {
-      continue;
-    }
-  }
-  if (best) {
-    return best.name;
-  }
-  throw new Error(
-    `[apm] \u65E0\u6CD5\u63A8\u65AD ${head} \u57FA\u4E8E\u54EA\u6761\u5206\u652F\u521B\u5EFA\uFF0C\u8BF7\u786E\u8BA4\u672C\u5730 reflog \u6216 origin \u8FDC\u7A0B\u5206\u652F`
-  );
+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 hasUpstream(cwd) {
   try {
@@ -670,7 +545,7 @@ async function pushCurrentBranch(cwd) {
   return true;
 }
 
-// src/workspace-repos.ts
+// src/utils/workspace-repos.ts
 import {
   existsSync as existsSync2,
   mkdirSync as mkdirSync3,
@@ -1052,7 +927,12 @@ async function runTaskBranch(taskId, options = {}) {
       cwd: gitRoot
     });
   }
-  return { branch, kind: manifest.kind, repos: repoRoots };
+  return {
+    branch,
+    baseline: baselineBranch,
+    kind: manifest.kind,
+    repos: repoRoots
+  };
 }
 
 // src/commands/connect/cursor-agent.ts
@@ -1060,9 +940,8 @@ import {
   Agent,
   CursorAgentError
 } from "@cursor/sdk";
-import { setMaxListeners as setMaxListeners2 } from "node:events";
 
-// src/plan-format.ts
+// src/utils/plan-format.ts
 function formatPlanMarkdown(raw) {
   let text = raw.trim();
   if (!text) {
@@ -1083,7 +962,7 @@ function formatPlanMarkdown(raw) {
   return text.replace(/\r\n/g, "\n").trimEnd() + "\n";
 }
 
-// src/session-utils.ts
+// src/utils/session.ts
 function serializeTokenUsage(usage) {
   return {
     inputTokens: usage.inputTokens,
@@ -1365,71 +1244,9 @@ ${JSON.stringify(event, null, 2)}
 \`\`\``;
 }
 
-// src/commands/connect/abort-signal-debug.ts
-import {
-  getEventListeners,
-  getMaxListeners,
-  setMaxListeners
-} from "node:events";
-function isAbortSignalDebugEnabled() {
-  const v = process.env.APM_DEBUG_ABORT_SIGNAL?.trim().toLowerCase();
-  return v === "1" || v === "true" || v === "yes";
-}
-function formatAbortSignalStats(signal, label) {
-  if (!signal) {
-    return `[apm:abort-debug] ${label}: (no signal)`;
-  }
-  const listeners = getEventListeners(signal, "abort");
-  const max = getMaxListeners(signal);
-  return `[apm:abort-debug] ${label}: abortListeners=${listeners.length} maxListeners=${max} aborted=${signal.aborted}`;
-}
-function logAbortSignalStats(signal, label) {
-  if (!isAbortSignalDebugEnabled()) return;
-  console.log(formatAbortSignalStats(signal, label));
-}
-var installed = false;
-function installAbortSignalDebug() {
-  if (!isAbortSignalDebugEnabled() || installed) return;
-  installed = true;
-  const maxFromEnv = Number.parseInt(
-    process.env.APM_ABORT_SIGNAL_MAX_LISTENERS ?? "",
-    10
-  );
-  if (Number.isFinite(maxFromEnv) && maxFromEnv > 0) {
-    setMaxListeners(maxFromEnv);
-    console.log(
-      `[apm:abort-debug] setMaxListeners(${maxFromEnv}) via APM_ABORT_SIGNAL_MAX_LISTENERS`
-    );
-  }
-  process.on("warning", (warning) => {
-    if (warning.name !== "MaxListenersExceededWarning") return;
-    console.warn(`[apm:abort-debug] ${warning.name}: ${warning.message}`);
-    if (warning.stack) {
-      console.warn(warning.stack);
-    }
-  });
-  const proto = AbortSignal.prototype;
-  const original = proto.addEventListener;
-  proto.addEventListener = function(type, listener, options) {
-    if (type === "abort") {
-      const sig = this;
-      const before = getEventListeners(sig, "abort").length;
-      const max = getMaxListeners(sig);
-      const stack = new Error("[apm:abort-debug] addEventListener stack").stack?.split("\n").slice(2, 8).join("\n") ?? "";
-      console.log(
-        `[apm:abort-debug] addEventListener("abort") before=${before} max=${max}
-${stack}`
-      );
-    }
-    return original.call(this, type, listener, options);
-  };
-  console.log(
-    "[apm:abort-debug] \u5DF2\u542F\u7528 AbortSignal \u8C03\u8BD5\uFF08APM_DEBUG_ABORT_SIGNAL\uFF09"
-  );
-}
-
-// src/commands/connect/append-message-tool.ts
-function createAppendMessageCustomTools(messageId, appendContent2) {
+// src/commands/connect/tools/append-message-tool.ts
+function createAppendMessageCustomTools(options) {
+  const { appendContent: appendContent2 } = options;
   return {
     AppendMessage: {
       description: "\u5411\u5F53\u524D WebIDE \u6D88\u606F\u8FFD\u52A0\u7528\u6237\u53EF\u89C1\u56DE\u590D\u3002\u53EF\u591A\u6B21\u8C03\u7528\u8865\u5145\u8FDB\u5C55\uFF1B\u88AB @ \u65F6\u6536\u5230\u540E\u5E94\u5148\u7B80\u77ED\u786E\u8BA4\u518D\u6267\u884C\u4EFB\u52A1\u3002\u7ED3\u8BBA\u4E0E\u8FDB\u5C55\u5E94\u5199\u5728\u672C\u5DE5\u5177\u4E2D\uFF1B\u6700\u7EC8\u81EA\u7136\u8BED\u8A00\u6536\u5C3E\u52FF\u518D\u590D\u8FF0\u6B64\u5904\u5185\u5BB9\u3002",
@@ -1453,7 +1270,6 @@ function createAppendMessageCustomTools(messageId, appendContent2) {
         }
         try {
           await appendContent2(content);
-          console.log(`[apm] AppendMessage \u5DF2\u8FFD\u52A0: messageId=${messageId}`);
           return "\u5DF2\u8FFD\u52A0\u6D88\u606F\u5185\u5BB9";
         } catch (err) {
           const detail = err instanceof Error ? err.message : String(err);
@@ -1467,7 +1283,7 @@ function createAppendMessageCustomTools(messageId, appendContent2) {
   };
 }
 
-// src/commands/connect/ask-question-tool.ts
+// src/commands/connect/tools/ask-question-tool.ts
 var INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -1505,121 +1321,118 @@ var INPUT_SCHEMA = {
 };
 function createAskQuestionTool(options) {
   return {
-    description: "Collect structured multiple-choice answers from the user. Use when blocked on a decision that is genuinely the user's to make.",
-    inputSchema: INPUT_SCHEMA,
-    execute: async (args) => {
-      options?.onInvoke?.(args);
-      if (options?.execute) {
-        return options.execute(args);
-      }
-      const payload = JSON.stringify(args, null, 2);
-      console.log(`[apm] AskQuestion\uFF08\u672C\u5730\u5360\u4F4D\uFF0C\u672A\u7B49\u5F85\u7528\u6237\uFF09:
+    AskQuestion: {
+      description: "Collect structured multiple-choice answers from the user. Use when blocked on a decision that is genuinely the user's to make.",
+      inputSchema: INPUT_SCHEMA,
+      execute: async (args) => {
+        options?.onInvoke?.(args);
+        if (options?.execute) {
+          return options.execute(args);
+        }
+        const payload = JSON.stringify(args, null, 2);
+        console.log(`[apm] AskQuestion\uFF08\u672C\u5730\u5360\u4F4D\uFF0C\u672A\u7B49\u5F85\u7528\u6237\uFF09:
 ${payload}`);
-      return `[local] AskQuestion \u5DF2\u8BB0\u5F55\uFF08\u672A\u521B\u5EFA\u4EFB\u52A1\u95EE\u9898\u3001\u672A\u7B49\u5F85\u7528\u6237\u56DE\u7B54\uFF09\u3002\u53C2\u6570:
+        return `[local] AskQuestion \u5DF2\u8BB0\u5F55\uFF08\u672A\u521B\u5EFA\u4EFB\u52A1\u95EE\u9898\u3001\u672A\u7B49\u5F85\u7528\u6237\u56DE\u7B54\uFF09\u3002\u53C2\u6570:
 ${payload}`;
+      }
     }
   };
 }
 
-// src/commands/connect/webide-merge-tools.ts
+// src/commands/connect/tools/webide-merge-tools.ts
 function createMergeWebIdePullRequestsTool(options) {
-  const { cfg, taskId } = options;
+  const { webideMergePullRequests } = options;
   return {
-    description: "Merge all open pull requests for this WebIDE task. Call once with confirmedConflictFree=true. No baseline sync or review is required before calling.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        confirmedConflictFree: {
-          type: "boolean",
-          description: "Must be true to confirm you intend to merge this task's open PRs now."
-        }
+    MergeWebIdePullRequests: {
+      description: "Merge all open pull requests for this WebIDE task. Call once with confirmedConflictFree=true. No baseline sync or review is required before calling.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          confirmedConflictFree: {
+            type: "boolean",
+            description: "Must be true to confirm you intend to merge this task's open PRs now."
+          }
+        },
+        required: ["confirmedConflictFree"]
       },
-      required: ["confirmedConflictFree"]
-    },
-    execute: async (args) => {
-      if (args.confirmedConflictFree !== true) {
-        throw new Error(
-          "MergeWebIdePullRequests \u8981\u6C42 confirmedConflictFree=true\u3002"
-        );
+      execute: async (args) => {
+        if (args.confirmedConflictFree !== true) {
+          throw new Error(
+            "MergeWebIdePullRequests \u8981\u6C42 confirmedConflictFree=true\u3002"
+          );
+        }
+        const result = await webideMergePullRequests();
+        return JSON.stringify(result, null, 2);
       }
-      const api = createApmApiClient(cfg);
-      console.log(`[apm] MergeWebIdePullRequests taskId=${taskId}`);
-      const result = await api.cli.webideMergePullRequests({ taskId });
-      return JSON.stringify(result, null, 2);
     }
   };
 }
 
-// src/commands/connect/webide-plan-tools.ts
+// src/commands/connect/tools/webide-plan-tools.ts
 function asString(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function createRecommendPlanTool(options) {
-  const { cfg, taskId } = options;
+  const { webideRecommendPlan } = options;
   return {
-    description: "Recommend whether the human should write an implementation plan or skip it. Does not change workflow phase; the human decides in the WebIDE UI.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        recommendation: {
-          type: "string",
-          enum: ["write", "skip", "unknown"],
-          description: "write = suggest generating a plan; skip = plan optional/unnecessary; unknown = unsure"
+    RecommendPlan: {
+      description: "Recommend whether the human should write an implementation plan or skip it. Does not change workflow phase; the human decides in the WebIDE UI.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          recommendation: {
+            type: "string",
+            enum: ["write", "skip", "unknown"],
+            description: "write = suggest generating a plan; skip = plan optional/unnecessary; unknown = unsure"
+          },
+          reason: {
+            type: "string",
+            description: "Short Chinese reason for the recommendation"
+          }
         },
-        reason: {
-          type: "string",
-          description: "Short Chinese reason for the recommendation"
-        }
+        required: ["recommendation"]
       },
-      required: ["recommendation"]
-    },
-    execute: async (args) => {
-      const raw = asString(args.recommendation);
-      const recommendation = raw === "write" || raw === "skip" || raw === "unknown" ? raw : "unknown";
-      const reason = asString(args.reason) || void 0;
-      const api = createApmApiClient(cfg);
-      await api.cli.webideRecommendPlan({
-        taskId,
-        recommendation,
-        reason
-      });
-      console.log(
-        `[apm] RecommendPlan taskId=${taskId} recommendation=${recommendation}`
-      );
-      return JSON.stringify({ ok: true, recommendation, reason }, null, 2);
+      execute: async (args) => {
+        const raw = asString(args.recommendation);
+        const recommendation = raw === "write" || raw === "skip" || raw === "unknown" ? raw : "unknown";
+        const reason = asString(args.reason) || void 0;
+        await webideRecommendPlan({
+          recommendation,
+          reason
+        });
+        return JSON.stringify({ ok: true, recommendation, reason }, null, 2);
+      }
     }
   };
 }
 function createUpsertWebIdePlanTool(options) {
-  const { cfg, taskId } = options;
+  const { webideUpsertPlan } = options;
   return {
-    description: "Persist or replace the implementation plan markdown for this WebIDE task and mark it ready for human confirmation. Call with the full plan document (not a diff). Use after generating or revising the plan.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        content: {
-          type: "string",
-          description: "Full implementation plan in Markdown (Chinese)"
-        }
+    UpsertWebIdePlan: {
+      description: "Persist or replace the implementation plan markdown for this WebIDE task and mark it ready for human confirmation. Call with the full plan document (not a diff). Use after generating or revising the plan.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: {
+            type: "string",
+            description: "Full implementation plan in Markdown (Chinese)"
+          }
+        },
+        required: ["content"]
       },
-      required: ["content"]
-    },
-    execute: async (args) => {
-      const content = asString(args.content);
-      if (!content) {
-        throw new Error("UpsertWebIdePlan \u7F3A\u5C11 content");
+      execute: async (args) => {
+        const content = asString(args.content);
+        if (!content) {
+          throw new Error("UpsertWebIdePlan \u7F3A\u5C11 content");
+        }
+        await webideUpsertPlan({ content });
+        return JSON.stringify({ ok: true, chars: content.length }, null, 2);
       }
-      const api = createApmApiClient(cfg);
-      await api.cli.webideUpsertPlan({ taskId, content });
-      console.log(
-        `[apm] UpsertWebIdePlan taskId=${taskId} chars=${content.length}`
-      );
-      return JSON.stringify({ ok: true, chars: content.length }, null, 2);
     }
   };
 }
 
-// src/commands/connect/webide-test-case-tools.ts
+// src/commands/connect/tools/webide-test-case-tools.ts
 function asString2(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -1647,222 +1460,62 @@ function parseCases(raw) {
   return cases;
 }
 function createUpsertWebIdeTestCasesTool(options) {
-  const { cfg, taskId } = options;
+  const { webideReplaceTestCases } = options;
   return {
-    description: "Persist generated automated test cases for this WebIDE task (full replace) and mark the workflow TEST_READY. Call once with the complete case list after reviewing the task and code changes.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        cases: {
-          type: "array",
-          description: "Complete list of test cases to store on the platform",
-          items: {
-            type: "object",
-            properties: {
-              name: {
-                type: "string",
-                description: "Short stable case id / name"
-              },
-              description: {
-                type: "string",
-                description: "What this case verifies (Chinese ok)"
-              },
-              steps: {
-                type: "array",
-                items: { type: "string" },
-                description: "Ordered human-readable steps"
+    UpsertWebIdeTestCases: {
+      description: "Persist generated automated test cases for this WebIDE task (full replace) and mark the workflow TEST_READY. Call once with the complete case list after reviewing the task and code changes.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cases: {
+            type: "array",
+            description: "Complete list of test cases to store on the platform",
+            items: {
+              type: "object",
+              properties: {
+                name: {
+                  type: "string",
+                  description: "Short stable case id / name"
+                },
+                description: {
+                  type: "string",
+                  description: "What this case verifies (Chinese ok)"
+                },
+                steps: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Ordered human-readable steps"
+                },
+                sortOrder: {
+                  type: "number",
+                  description: "Optional display order (0-based)"
+                }
               },
-              sortOrder: {
-                type: "number",
-                description: "Optional display order (0-based)"
-              }
-            },
-            required: ["name", "description", "steps"]
+              required: ["name", "description", "steps"]
+            }
           }
-        }
-      },
-      required: ["cases"]
-    },
-    execute: async (args) => {
-      const cases = parseCases(args.cases);
-      if (cases.length === 0) {
-        throw new Error(
-          "UpsertWebIdeTestCases \u7F3A\u5C11\u6709\u6548 cases\uFF08\u6BCF\u6761\u9700 name \u4E0E\u975E\u7A7A steps\uFF09"
-        );
-      }
-      const api = createApmApiClient(cfg);
-      const result = await api.cli.webideReplaceTestCases({ taskId, cases });
-      console.log(
-        `[apm] UpsertWebIdeTestCases taskId=${taskId} count=${cases.length}`
-      );
-      return JSON.stringify(
-        { ok: true, count: result.count ?? cases.length },
-        null,
-        2
-      );
-    }
-  };
-}
-
-// src/commands/connect/webide-terminal-tools.ts
-function asString3(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-function asPorts(value) {
-  if (!Array.isArray(value)) return void 0;
-  const ports = value.map((p) => typeof p === "number" ? p : Number(p)).filter((p) => Number.isFinite(p) && p > 0 && p < 65536).map((p) => Math.trunc(p));
-  return ports.length ? ports : void 0;
-}
-function createWebIdeTerminalTools(options) {
-  const { cfg, taskId, workdir, rpc } = options;
-  const StartWebIdeTerminal = {
-    description: "Start a long-running WebIDE terminal (e.g. frontend/backend dev server). Process outlives this message. Same key already RUNNING/READY returns idempotently. Do NOT use Shell for long-lived dev servers. Returns terminalId, pid, ports.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        key: {
-          type: "string",
-          description: "Stable key, e.g. frontend / backend"
-        },
-        name: { type: "string", description: "Display name" },
-        cwd: {
-          type: "string",
-          description: "Working directory (absolute or under workspace)"
         },
-        command: {
-          type: "string",
-          description: "Shell command to run, e.g. pnpm dev"
-        },
-        readyPattern: {
-          type: "string",
-          description: "Optional regex; when matched in logs, status becomes READY"
-        },
-        portsHint: {
-          type: "array",
-          items: { type: "number" },
-          description: "Optional expected listen ports"
-        }
+        required: ["cases"]
       },
-      required: ["key", "cwd", "command"]
-    },
-    execute: async (args) => {
-      const key = asString3(args.key);
-      const cwd = asString3(args.cwd) || workdir;
-      const command = asString3(args.command);
-      if (!key || !command) {
-        return {
-          content: [{ type: "text", text: "key / command \u4E0D\u80FD\u4E3A\u7A7A" }],
-          isError: true
-        };
-      }
-      try {
-        const result = rpc ? await rpc.start({
-          taskId,
-          key,
-          name: asString3(args.name) || void 0,
-          cwd,
-          command,
-          readyPattern: asString3(args.readyPattern) || void 0,
-          portsHint: asPorts(args.portsHint)
-        }) : await (async () => {
-          throw new Error("Terminal RPC \u4E0D\u53EF\u7528\uFF08\u9700\u5728 connect \u4E3B\u8FDB\u7A0B\uFF09");
-        })();
-        return JSON.stringify(result, null, 2);
-      } catch (err) {
-        const detail = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: `\u542F\u52A8\u7EC8\u7AEF\u5931\u8D25: ${detail}` }],
-          isError: true
-        };
-      }
-    }
-  };
-  const StopWebIdeTerminal = {
-    description: "Stop a WebIDE terminal and kill its process tree. Soft-terminates (status EXITED, record kept).",
-    inputSchema: {
-      type: "object",
-      properties: {
-        key: { type: "string", description: "Terminal key" },
-        terminalId: { type: "string", description: "Server terminal id" }
-      }
-    },
-    execute: async (args) => {
-      const key = asString3(args.key) || void 0;
-      const terminalId = asString3(args.terminalId) || void 0;
-      if (!key && !terminalId) {
-        return {
-          content: [{ type: "text", text: "\u9700\u8981 key \u6216 terminalId" }],
-          isError: true
-        };
-      }
-      try {
-        const result = rpc ? await rpc.stop({ taskId, key, terminalId }) : await (async () => {
-          throw new Error("Terminal RPC \u4E0D\u53EF\u7528\uFF08\u9700\u5728 connect \u4E3B\u8FDB\u7A0B\uFF09");
-        })();
-        return JSON.stringify(result, null, 2);
-      } catch (err) {
-        const detail = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: `\u505C\u6B62\u7EC8\u7AEF\u5931\u8D25: ${detail}` }],
-          isError: true
-        };
-      }
-    }
-  };
-  const StopAllWebIdeTerminals = {
-    description: "Stop all living WebIDE terminals for the current task (kill process trees). Use before re-running local dev to avoid port conflicts. Soft-terminates records.",
-    inputSchema: {
-      type: "object",
-      properties: {}
-    },
-    execute: async () => {
-      try {
-        const result = rpc ? await rpc.stopAll({ taskId }) : await (async () => {
-          throw new Error("Terminal RPC \u4E0D\u53EF\u7528\uFF08\u9700\u5728 connect \u4E3B\u8FDB\u7A0B\uFF09");
-        })();
-        return JSON.stringify(result, null, 2);
-      } catch (err) {
-        const detail = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: `\u5168\u90E8\u505C\u6B62\u5931\u8D25: ${detail}` }],
-          isError: true
-        };
-      }
-    }
-  };
-  const ListWebIdeTerminals = {
-    description: "List living WebIDE terminals for the current task (STARTING/RUNNING/READY/STOPPING only). Does NOT include EXITED/FAILED. Returns id, key, status, pid, ports.",
-    inputSchema: {
-      type: "object",
-      properties: {}
-    },
-    execute: async () => {
-      try {
-        if (rpc) {
-          const result2 = await rpc.list({ taskId });
-          return JSON.stringify(result2, null, 2);
+      execute: async (args) => {
+        const cases = parseCases(args.cases);
+        if (cases.length === 0) {
+          throw new Error(
+            "UpsertWebIdeTestCases \u7F3A\u5C11\u6709\u6548 cases\uFF08\u6BCF\u6761\u9700 name \u4E0E\u975E\u7A7A steps\uFF09"
+          );
         }
-        const api = createApmApiClient(cfg);
-        const result = await api.cli.webideListTerminals({ taskId });
-        return JSON.stringify(result, null, 2);
-      } catch (err) {
-        const detail = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: `\u5217\u51FA\u7EC8\u7AEF\u5931\u8D25: ${detail}` }],
-          isError: true
-        };
+        const result = await webideReplaceTestCases({ cases });
+        return JSON.stringify(
+          { ok: true, count: result.count ?? cases.length },
+          null,
+          2
+        );
       }
     }
   };
-  return {
-    StartWebIdeTerminal,
-    StopWebIdeTerminal,
-    StopAllWebIdeTerminals,
-    ListWebIdeTerminals
-  };
 }
 
-// src/commands/connect/cursor-custom-tools.ts
+// 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
@@ -1870,39 +1523,33 @@ AskQuestion \u5DF2\u901A\u8FC7 MCP \u670D\u52A1\u5668 custom-user-tools \u6CE8\u
 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 createCursorCustomTools(cfg, messageId, options) {
+function createCursorCustomTools(cfg, options) {
   const tools = {
-    ...createAppendMessageCustomTools(messageId, options.appendMessageContent),
-    AskQuestion: createAskQuestionTool({
+    ...options.enableAppendMessage !== false && options.appendMessageContent ? createAppendMessageCustomTools({
+      appendContent: options.appendMessageContent
+    }) : {},
+    ...createAskQuestionTool({
       onInvoke: options?.onAskQuestion,
       execute: options?.askQuestionExecute
     })
   };
-  if (options?.enableWebIdePlanTools && options.taskId) {
-    tools.RecommendPlan = createRecommendPlanTool({
-      cfg,
-      taskId: options.taskId
-    });
-    tools.UpsertWebIdePlan = createUpsertWebIdePlanTool({
-      cfg,
-      taskId: options.taskId
-    });
-    tools.UpsertWebIdeTestCases = createUpsertWebIdeTestCasesTool({
-      cfg,
-      taskId: options.taskId
-    });
-    tools.MergeWebIdePullRequests = createMergeWebIdePullRequestsTool({
-      cfg,
-      taskId: options.taskId
-    });
-    if (options.workdir) {
+  if (options?.taskId && options.workdir) {
+    const { cli } = createApmApiClient(cfg);
+    const taskId = options.taskId;
+    if (options.enableWebIdePlanTools) {
       Object.assign(
         tools,
-        createWebIdeTerminalTools({
-          cfg,
-          taskId: options.taskId,
-          workdir: options.workdir,
-          rpc: options.terminalRpc
+        createRecommendPlanTool({
+          webideRecommendPlan: (args) => cli.webideRecommendPlan({ taskId, ...args })
+        }),
+        createUpsertWebIdePlanTool({
+          webideUpsertPlan: (args) => cli.webideUpsertPlan({ taskId, ...args })
+        }),
+        createUpsertWebIdeTestCasesTool({
+          webideReplaceTestCases: (args) => cli.webideReplaceTestCases({ taskId, ...args })
+        }),
+        createMergeWebIdePullRequestsTool({
+          webideMergePullRequests: () => cli.webideMergePullRequests({ taskId })
         })
       );
     }
@@ -1923,9 +1570,30 @@ function withWorkspaceBoundaryHint(prompt) {
 ${WORKSPACE_BOUNDARY_HINT}`;
 }
 
+// src/commands/connect/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 port = env.LOCAL_TERMINAL_PORT?.trim() || DEFAULT_PTY_SESSION_PORT;
+  return `http://127.0.0.1:${port}`;
+}
+function createPtySessionMcpServers(cfg) {
+  const token = resolveApiKey(cfg);
+  if (!token) return void 0;
+  return {
+    [PTY_SESSION_MCP_NAME]: {
+      type: "http",
+      url: `${resolvePtySessionBaseUrl()}/mcp`,
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    }
+  };
+}
+
 // src/commands/connect/cursor-agent.ts
-setMaxListeners2(100);
-installAbortSignalDebug();
 var noopRemoteLogSync = {
   schedule(_session) {
   },
@@ -1988,7 +1656,6 @@ async function obtainAgent(ctx) {
 }
 async function runCursorAgent(cfg, ctx, options) {
   const signal = options.signal;
-  logAbortSignalStats(signal, "runCursorAgent:start");
   if (signal?.aborted) {
     throw new Error("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u4EFB\u52A1\u4E2D\u65AD");
   }
@@ -1997,16 +1664,17 @@ async function runCursorAgent(cfg, ctx, options) {
     throw new Error("\u7F3A\u5C11 apiKey\uFF0C\u65E0\u6CD5\u8C03\u7528 Cursor SDK");
   }
   const workdir = resolveWorkdirPath(ctx.workdir);
-  const customTools = createCursorCustomTools(cfg, ctx.messageId, {
+  const customTools = createCursorCustomTools(cfg, {
     onAskQuestion: options.onAskQuestion,
     appendMessageContent: options.appendMessageContent,
+    enableAppendMessage: options.enableAppendMessage,
     askQuestionExecute: options.askQuestionExecute,
     enableWebIdePlanTools: options.enableWebIdePlanTools,
     taskId: options.taskId,
-    workdir,
-    terminalRpc: options.terminalRpc
+    workdir
   });
   const enableSandbox = Boolean(options.enableSandbox);
+  const mcpServers = options.enablePtySessionMcp ? createPtySessionMcpServers(cfg) : void 0;
   let prompt = withPlanModeToolHint(ctx.prompt, ctx.mode);
   prompt = withWorkspaceBoundaryHint(prompt);
   console.log(
@@ -2021,6 +1689,7 @@ async function runCursorAgent(cfg, ctx, options) {
     resumeAgentId: ctx.resumeAgentId,
     customTools,
     enableSandbox,
+    mcpServers,
     onInvalidatePersistedAgentId: options.onInvalidatePersistedAgentId
   });
   const invalidateAgentMapping = () => {
@@ -2034,7 +1703,6 @@ async function runCursorAgent(cfg, ctx, options) {
     void activeRun.cancel().catch(() => void 0);
   };
   signal?.addEventListener("abort", abortRun, { once: true });
-  logAbortSignalStats(signal, "runCursorAgent:after-addListener");
   try {
     const run = await agent.send(prompt, {
       ...ctx.mode ? { mode: ctx.mode } : {},
@@ -2044,7 +1712,6 @@ async function runCursorAgent(cfg, ctx, options) {
       }
     });
     activeRun = run;
-    logAbortSignalStats(signal, "runCursorAgent:after-send");
     console.log(`[apm] Cursor run id=${run.id} agentId=${agent.agentId}`);
     await options.onRunStarted?.({ agentId: agent.agentId, runId: run.id });
     let lastRunErrorStatus;
@@ -2131,9 +1798,7 @@ async function runCursorAgent(cfg, ctx, options) {
     }
     throw err;
   } finally {
-    logAbortSignalStats(signal, "runCursorAgent:finally-before-cleanup");
     signal?.removeEventListener("abort", abortRun);
-    logAbortSignalStats(signal, "runCursorAgent:finally-after-cleanup");
     await agent[Symbol.asyncDispose]();
   }
 }
@@ -2309,11 +1974,11 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir) {
 // src/commands/connect/webide-ask-question.ts
 import { setTimeout as delay } from "node:timers/promises";
 var POLL_INTERVAL_MS = 2e3;
-function asString4(value) {
+function asString3(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function parseQuestions(args) {
-  const title = asString4(args.title) || void 0;
+  const title = asString3(args.title) || void 0;
   const raw = args.questions;
   if (!Array.isArray(raw) || raw.length === 0) {
     throw new Error("AskQuestion \u7F3A\u5C11 questions");
@@ -2322,16 +1987,16 @@ function parseQuestions(args) {
   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 id = asString3(row.id);
+    const prompt = asString3(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);
+      const oid = asString3(o.id);
+      const label = asString3(o.label);
       if (oid && label) options.push({ id: oid, label });
     }
     if (options.length < 2) {
@@ -2365,11 +2030,11 @@ function createWebIdeAskQuestionExecute(options) {
       const byId = new Map(
         list.assumptions.map((a) => [a.questionId, a])
       );
-      const pending2 = parsed.questions.filter((q) => {
+      const pending = parsed.questions.filter((q) => {
         const row = byId.get(q.id);
         return !row || row.status !== "RESOLVED";
       });
-      if (pending2.length === 0) {
+      if (pending.length === 0) {
         const answers = parsed.questions.map((q) => {
           const row = byId.get(q.id);
           return {
@@ -2397,7 +2062,7 @@ function createWebIdeAskQuestionExecute(options) {
   };
 }
 
-// src/commands/deploy/internal/minio.ts
+// src/utils/minio.ts
 import * as Minio from "minio";
 var MinioClient = class {
   inner;
@@ -2417,45 +2082,9 @@ var MinioClient = class {
       await this.inner.makeBucket(bucket);
     }
   }
-  async deleteObjectsByPrefix(bucket, prefix) {
-    const objectsStream = this.inner.listObjectsV2(bucket, prefix, true);
-    const keys = [];
-    await new Promise((resolve6, reject) => {
-      objectsStream.on("data", (obj) => {
-        if (obj.name) {
-          keys.push(obj.name);
-        }
-      });
-      objectsStream.on("error", reject);
-      objectsStream.on("end", resolve6);
-    });
-    const chunkSize = 500;
-    for (let i = 0; i < keys.length; i += chunkSize) {
-      const chunk = keys.slice(i, i + chunkSize);
-      await this.inner.removeObjects(
-        bucket,
-        chunk.map((name) => name)
-      );
-    }
-  }
   async putObject(bucket, objectKey, body, meta) {
     await this.inner.putObject(bucket, objectKey, body, body.length, meta);
   }
-  /** 匿名可读当前桶全部对象（便于静态站点直链） */
-  async setBucketPublicRead(bucket) {
-    const policy = {
-      Version: "2012-10-17",
-      Statement: [
-        {
-          Effect: "Allow",
-          Principal: { AWS: ["*"] },
-          Action: ["s3:GetObject"],
-          Resource: [`arn:aws:s3:::${bucket}/*`]
-        }
-      ]
-    };
-    await this.inner.setBucketPolicy(bucket, JSON.stringify(policy));
-  }
 };
 
 // src/commands/connect/apm-log-minio.ts
@@ -2740,7 +2369,7 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
     };
   }
   if (!projectBaseBranch) {
-    const tip = "\u9879\u76EE\u672A\u914D\u7F6E\u57FA\u7840\u5206\u652F\uFF0C\u65E0\u6CD5\u6309\u57FA\u7EBF\u5339\u914D\u5E73\u53F0\u4ED3\u5E93";
+    const tip = "\u9879\u76EE\u672A\u914D\u7F6E\u57FA\u7840\u5206\u652F\uFF0C\u65E0\u6CD5\u521B\u5EFA PR";
     console.warn(`[apm] WebIDE PR\uFF1A${tip}`);
     return {
       ...empty(),
@@ -2790,7 +2419,7 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
         continue;
       }
       const headBranch = current;
-      const originUrl = await tryReadGitOriginUrl(gitRoot);
+      const originUrl = await tryReadHttpsGitOriginUrl(gitRoot) ?? await tryReadGitOriginUrl(gitRoot);
       if (!originUrl) {
         const tip = `${label}\uFF1A\u65E0 remote.origin.url`;
         console.warn(`[apm] WebIDE PR\uFF1A\u8DF3\u8FC7 ${tip}`);
@@ -2804,29 +2433,7 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
         });
         continue;
       }
-      const matched = await api.cli.matchRepository({
-        url: originUrl,
-        baseBranch: projectBaseBranch
-      });
-      const repositoryId = matched.repositoryId?.trim();
-      if (!repositoryId) {
-        const tip = `${label}\uFF1A\u5E73\u53F0\u672A\u627E\u5230\u4ED3\u5E93\uFF08remote=${originUrl}\uFF0C\u57FA\u7EBF=${projectBaseBranch}\uFF09`;
-        console.warn(`[apm] WebIDE PR\uFF1A\u8DF3\u8FC7 ${tip}`);
-        tips.push(tip);
-        skipped += 1;
-        items.push({
-          label,
-          outcome: "skipped",
-          headBranch,
-          baseBranch: projectBaseBranch,
-          detail: tip
-        });
-        continue;
-      }
-      const baseBranch = await resolveFeatureBranchBaseFromGit(
-        gitRoot,
-        headBranch
-      );
+      const baseBranch = projectBaseBranch;
       const hasChanges = await branchHasChangesAgainstBase(
         gitRoot,
         baseBranch,
@@ -2848,7 +2455,7 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
       }
       const pr = await api.cli.createWebIdeDraftPullRequest({
         taskId,
-        repositoryId,
+        originUrl,
         headBranch,
         baseBranch
       });
@@ -2983,7 +2590,7 @@ async function syncWebIdeAttachments(cfg, taskId, workdir, attachments) {
   );
 }
 
-// src/project-documents-sync.ts
+// src/utils/project-documents.ts
 import {
   existsSync as existsSync6,
   readdirSync as readdirSync3,
@@ -3095,24 +2702,25 @@ async function resolveProjectIdForSync(api, workdirPath, options) {
     return { projectId: explicit, diagnostic: null };
   }
   try {
-    const baseline = await api.cli.workspaceBaseline({ workdirPath });
-    const projectId = baseline.projectId?.trim() || null;
-    if (projectId) {
-      return { projectId, diagnostic: null };
+    const 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 projectIds = baseline.projectIds ?? [];
-    if (projectIds.length === 0) {
+    const baseline = await api.cli.projectBaseBranch({ taskId });
+    const projectId = baseline.projectId?.trim() || null;
+    if (!projectId) {
       return {
         projectId: null,
-        diagnostic: baseline.diagnostic?.message ?? `\u5DE5\u4F5C\u7A7A\u95F4\u672A\u5173\u8054\u9879\u76EE\uFF0C\u65E0\u6CD5\u540C\u6B65\u9879\u76EE\u6587\u6863\uFF08\u76EE\u5F55\uFF1A${workdirPath}\uFF09\u3002
-\u8BF7\u5728\u5E73\u53F0\u5C06\u5DE5\u4F5C\u7A7A\u95F4\u5173\u8054\u5230\u552F\u4E00\u9879\u76EE\u3002`
+        diagnostic: `\u4EFB\u52A1 ${taskId} \u672A\u5173\u8054\u9879\u76EE\uFF0C\u65E0\u6CD5\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002`
       };
     }
-    return {
-      projectId: null,
-      diagnostic: `\u5DE5\u4F5C\u7A7A\u95F4\u5173\u8054\u4E86 ${projectIds.length} \u4E2A\u9879\u76EE\uFF0C\u65E0\u6CD5\u786E\u5B9A\u540C\u6B65\u76EE\u6807\u3002
-\u8BF7\u786E\u4FDD\u8BE5\u5DE5\u4F5C\u7A7A\u95F4\u53EA\u5173\u8054\u4E00\u4E2A\u9879\u76EE\u540E\u518D\u540C\u6B65\u9879\u76EE\u6587\u6863\u3002`
-    };
+    return { projectId, diagnostic: null };
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     return {
@@ -3331,7 +2939,7 @@ async function appendContent(cfg, messageId, content) {
   const api = createApmApiClient(cfg);
   await api.cli.webideAppendMessageContent({ id: messageId, content });
 }
-async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
+async function handleWebIdeInboundMessage(cfg, msg, signal) {
   const workdir = requireRemoteWorkdir(msg.workdir);
   const messageId = msg.messageId;
   const taskId = msg.taskId;
@@ -3429,7 +3037,7 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
         async () => runTaskBranch(taskId, { cwd: workdir }),
         (branchResult) => {
           markBranchDone(branchCacheKey, workdir);
-          return `kind=${branchResult.kind} branch=${branchResult.branch} repos=${branchResult.repos.length}`;
+          return `kind=${branchResult.kind} branch=${branchResult.branch} baseline=${branchResult.baseline} repos=${branchResult.repos.length}`;
         }
       );
     } else {
@@ -3546,7 +3154,6 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
         enableSandbox: false,
         onInvalidatePersistedAgentId: () => clearWebIdeAgentId(workdir, taskId),
         taskId,
-        terminalRpc: options?.terminalRpc,
         createRemoteLogSync: (agentId) => {
           saveWebIdeAgentId(workdir, taskId, agentId);
           logSyncRef.current = createThrottledWebIdeMessageLogSync(
@@ -3738,68 +3345,166 @@ async function handleWebIdeInboundMessage(cfg, msg, signal, options) {
   }
 }
 
-// src/commands/connect/webide-terminal-rpc.ts
-import { parentPort } from "node:worker_threads";
-var nextId = 1;
-var pending = /* @__PURE__ */ new Map();
-function installTerminalRpcListener() {
-  parentPort?.on("message", (raw) => {
-    if (!raw || raw.type !== "terminal-rpc-result") return;
-    const p = pending.get(raw.id);
-    if (!p) return;
-    pending.delete(raw.id);
-    if (raw.ok) p.resolve(raw.result);
-    else p.reject(new Error(raw.error || "terminal rpc failed"));
-  });
+// src/commands/connect/handle-start-project.ts
+async function updateStatus2(cfg, messageId, status) {
+  const api = createApmApiClient(cfg);
+  await api.cli.webideUpdateMessageStatus({ id: messageId, status });
+}
+async function setError2(cfg, messageId, error) {
+  const api = createApmApiClient(cfg);
+  await api.cli.webideSetMessageError({ id: messageId, error });
 }
-function call(op, args) {
-  const id = nextId++;
-  return new Promise((resolve6, reject) => {
-    if (!parentPort) {
-      reject(new Error("parentPort \u4E0D\u53EF\u7528"));
+async function handleStartProject(cfg, msg, signal) {
+  const workdir = requireRemoteWorkdir(msg.workdir);
+  const messageId = msg.messageId;
+  const taskId = msg.taskId;
+  console.log(
+    `[apm] webide-start-project target=${msg.target} restart=${msg.restart} taskId=${taskId} messageId=${messageId}`
+  );
+  await updateStatus2(cfg, messageId, "TYPING");
+  const eventSession = new EventSession(msg.content);
+  const logSyncRef = {
+    current: createThrottledWebIdeMessageLogSync(
+      cfg,
+      { 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);
+    const api = createApmApiClient(cfg);
+    const outcome = await runCursorAgent(
+      cfg,
+      {
+        messageId,
+        prompt: msg.content,
+        model: msg.model,
+        apiKey: msg.apiKey,
+        workdir,
+        user: msg.user || "webide"
+      },
+      {
+        signal,
+        forceSend: true,
+        eventSession,
+        enableAppendMessage: false,
+        askQuestionExecute: async () => "\u8FD9\u662F\u65E0\u4EBA\u503C\u5B88\u7684\u542F\u52A8\u4EFB\u52A1\uFF0C\u8BF7\u6839\u636E deploy.md \u81EA\u884C\u51B3\u5B9A\uFF0C\u4E0D\u8981\u7B49\u5F85\u7528\u6237\u3002",
+        enableWebIdePlanTools: false,
+        enablePtySessionMcp: true,
+        enableSandbox: false,
+        taskId,
+        createRemoteLogSync: (agentId) => {
+          logSyncRef.current = createThrottledWebIdeMessageLogSync(
+            cfg,
+            { 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);
+        }
+      }
+    );
+    const tokenUsage = outcome.usage != null ? {
+      modelId: outcome.modelId ?? (msg.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 setError2(cfg, messageId, detail);
+      return;
+    }
+    if (outcome.status === "cancelled" || signal.aborted) {
+      await logSyncRef.current?.markRun(
+        outcome.runId,
+        "cancelled",
+        "\u5DF2\u53D6\u6D88",
+        tokenUsage
+      );
+      await updateStatus2(cfg, messageId, "CANCELLED");
       return;
     }
-    pending.set(id, { resolve: resolve6, reject });
-    parentPort.postMessage({
-      type: "terminal-rpc",
-      id,
-      op,
-      args
+    const fallback = resolveMessageReplyFallback({
+      assistantText: outcome.assistantText,
+      result: outcome.result
     });
-    setTimeout(() => {
-      if (pending.has(id)) {
-        pending.delete(id);
-        reject(new Error(`terminal rpc timeout op=${op}`));
-      }
-    }, 12e4);
-  });
-}
-function createWorkerTerminalRpc() {
-  return {
-    start: (args) => call("start", args),
-    stop: (args) => call("stop", args),
-    stopAll: (args) => call("stopAll", args),
-    list: (args) => call("list", args)
-  };
+    await api.cli.webideEnsureMessageContent({
+      id: messageId,
+      content: fallback
+    });
+    await logSyncRef.current?.markRun(
+      outcome.runId,
+      "finished",
+      null,
+      tokenUsage
+    );
+    await updateStatus2(cfg, messageId, "SUCCESS");
+    console.log(
+      `[apm] webide-start-project \u5B8C\u6210 target=${msg.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 setError2(cfg, messageId, detail);
+    } catch (statusErr) {
+      console.error(
+        "[apm] \u5199\u5165\u542F\u52A8\u9879\u76EE FAILED \u5931\u8D25:",
+        statusErr instanceof Error ? statusErr.message : statusErr
+      );
+    }
+  }
 }
 
 // src/commands/connect/webide-message-worker.ts
 var controllers = /* @__PURE__ */ new Map();
-installTerminalRpcListener();
-var terminalRpc = createWorkerTerminalRpc();
 async function runJob(cfg, msg) {
   const controller = new AbortController();
   controllers.set(msg.messageId, controller);
   try {
-    await handleWebIdeInboundMessage(cfg, msg, controller.signal, {
-      terminalRpc
-    });
-    parentPort2?.postMessage({
+    if (msg.type === "webide-start-project") {
+      await handleStartProject(cfg, msg, controller.signal);
+    } else {
+      await handleWebIdeInboundMessage(cfg, msg, controller.signal);
+    }
+    parentPort?.postMessage({
       type: "done",
       messageId: msg.messageId
     });
   } catch (err) {
-    parentPort2?.postMessage({
+    parentPort?.postMessage({
       type: "error",
       messageId: msg.messageId,
       error: err instanceof Error ? err.message : String(err)
@@ -3808,7 +3513,7 @@ async function runJob(cfg, msg) {
     controllers.delete(msg.messageId);
   }
 }
-parentPort2?.on("message", (raw) => {
+parentPort?.on("message", (raw) => {
   if (raw.type === "cancel") {
     controllers.get(raw.messageId)?.abort();
     return;