ai-project-manage-cli 8.1.6 → 8.1.8

package/dist/worker-script.js

@@ -14,6 +14,10 @@ var requestConfig = {
         path: "/cli/me"
       }
     ),
+    webideAgentConfig: defineEndpoint({
+      method: "GET",
+      path: "/cli/webide/agent-config"
+    }),
     webideAppendMessageContent: defineEndpoint({
       method: "PUT",
       path: "/cli/webide/messages/content"
@@ -72,6 +76,14 @@ var requestConfig = {
       method: "PUT",
       path: "/cli/webide/plan"
     }),
+    webideUpsertChecklist: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/checklist"
+    }),
+    webideGetChecklist: defineEndpoint({
+      method: "GET",
+      path: "/cli/webide/checklist"
+    }),
     webideReplaceTestCases: defineEndpoint({
       method: "PUT",
       path: "/cli/webide/test-cases"
@@ -317,11 +329,8 @@ function requireRemoteWorkdir(workdir) {
 }
 
 // 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";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var CLI_TEMPLATE_DIR = resolve2(__dirname, "../template");
+import { existsSync, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
 function workspaceApmDir(cwd = resolveWorkdirPath()) {
   return resolve2(resolve2(cwd), ".apm");
 }
@@ -372,90 +381,6 @@ async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
   }
   mkdirSync2(fsDir, { recursive: true });
 }
-var WEBIDE_AGENTS_TEMPLATE_NAME = "AGENTS.webide.md";
-function shouldSkipTemplateEntry(name) {
-  return name === ".DS_Store" || name === "Thumbs.db";
-}
-function isWebIdeRuleFileName(name) {
-  return name.startsWith("webide");
-}
-function copyTemplateEntry(src, dest) {
-  const fsSrc = toFsPath(src);
-  const fsDest = toFsPath(dest);
-  const st = statSync(fsSrc);
-  if (st.isDirectory()) {
-    mkdirSync2(fsDest, { recursive: true });
-    for (const name of readdirSync(fsSrc)) {
-      if (shouldSkipTemplateEntry(name)) continue;
-      copyTemplateEntry(join2(src, name), join2(dest, name));
-    }
-    return;
-  }
-  if (!st.isFile()) return;
-  mkdirSync2(toFsPath(dirname(dest)), { recursive: true });
-  copyFileSync(fsSrc, fsDest);
-}
-function listWebIdeRuleFileNames(rulesDir) {
-  const fsRulesDir = toFsPath(rulesDir);
-  if (!existsSync(fsRulesDir) || !statSync(fsRulesDir).isDirectory()) {
-    return [];
-  }
-  return readdirSync(fsRulesDir).filter((name) => {
-    if (shouldSkipTemplateEntry(name) || !isWebIdeRuleFileName(name)) {
-      return false;
-    }
-    return statSync(toFsPath(join2(rulesDir, name))).isFile();
-  });
-}
-function assertWebIdeTemplateCopiedToApm(apmDir, workdir) {
-  const required = ["AGENTS.md", "rules"];
-  for (const item of required) {
-    const path3 = join2(apmDir, item);
-    if (!existsSync(toFsPath(path3))) {
-      throw new Error(`[apm] WebIDE \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path3}`);
-    }
-  }
-  const rulesDir = join2(apmDir, "rules");
-  const ruleNames = listWebIdeRuleFileNames(rulesDir);
-  if (ruleNames.length === 0) {
-    throw new Error(`[apm] WebIDE \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11 webide \u89C4\u5219: ${rulesDir}`);
-  }
-  const leakedRules = join2(workdir, "rules");
-  const apmRules = join2(apmDir, "rules");
-  if (existsSync(toFsPath(leakedRules)) && !existsSync(toFsPath(join2(apmRules, "webide_reply.md")))) {
-    throw new Error(
-      `[apm] \u6A21\u677F\u88AB\u590D\u5236\u5230\u9519\u8BEF\u4F4D\u7F6E: ${leakedRules}\uFF08\u5E94\u5728 ${apmRules}\uFF09`
-    );
-  }
-}
-async function copyWebIdeTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
-  const resolvedTarget = resolve2(targetDir);
-  const templateDir = resolve2(CLI_TEMPLATE_DIR);
-  const fsTemplateDir = toFsPath(templateDir);
-  if (!existsSync(fsTemplateDir) || !statSync(fsTemplateDir).isDirectory()) {
-    throw new Error(`[apm] \u672A\u627E\u5230 CLI \u6A21\u677F\u76EE\u5F55: ${templateDir}`);
-  }
-  const agentsSrc = join2(templateDir, WEBIDE_AGENTS_TEMPLATE_NAME);
-  if (!existsSync(toFsPath(agentsSrc))) {
-    throw new Error(`[apm] \u672A\u627E\u5230 WebIDE \u6307\u5357: ${agentsSrc}`);
-  }
-  const rulesSrc = join2(templateDir, "rules");
-  const ruleNames = listWebIdeRuleFileNames(rulesSrc);
-  if (ruleNames.length === 0) {
-    throw new Error(`[apm] CLI \u6A21\u677F\u4E2D\u6CA1\u6709 webide \u89C4\u5219: ${rulesSrc}`);
-  }
-  mkdirSync2(toFsPath(resolvedTarget), { recursive: true });
-  copyFileSync(
-    toFsPath(agentsSrc),
-    toFsPath(join2(resolvedTarget, "AGENTS.md"))
-  );
-  const rulesDest = join2(resolvedTarget, "rules");
-  mkdirSync2(toFsPath(rulesDest), { recursive: true });
-  for (const name of ruleNames) {
-    copyTemplateEntry(join2(rulesSrc, name), join2(rulesDest, name));
-  }
-  assertWebIdeTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
-}
 
 // src/utils/git.ts
 import { execFile as execFile2 } from "child_process";
@@ -656,7 +581,7 @@ import {
   statSync as statSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import { basename, dirname as dirname2, join as join3, relative, resolve as resolve3 } from "path";
+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"]);
@@ -1499,7 +1424,7 @@ function createMergeWebIdePullRequestsTool(options) {
   const { webideMergePullRequests } = options;
   return {
     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.",
+      description: "Merge all open pull requests for this WebIDE task. During accept, call UpsertWebIdeChecklist first with the full acceptance checklist, then call this once with confirmedConflictFree=true. No baseline sync is required before merging.",
       inputSchema: {
         type: "object",
         properties: {
@@ -1586,6 +1511,63 @@ function createUpsertWebIdePlanTool(options) {
     }
   };
 }
+function createUpsertWebIdeChecklistTool(options) {
+  const { webideUpsertChecklist } = options;
+  return {
+    UpsertWebIdeChecklist: {
+      description: "Persist or replace the acceptance checklist markdown for this WebIDE task. Call with the full checklist (what changed, which repos/files, how to verify) before merging PRs. Use during accept so humans can review later.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: {
+            type: "string",
+            description: "Full acceptance checklist in Markdown (Chinese): summary of code changes, scope by repo, key files, verification notes"
+          }
+        },
+        required: ["content"]
+      },
+      execute: async (args) => {
+        const content = asString(args.content);
+        if (!content) {
+          throw new Error("UpsertWebIdeChecklist \u7F3A\u5C11 content");
+        }
+        await webideUpsertChecklist({ content });
+        return JSON.stringify({ ok: true, chars: content.length }, null, 2);
+      }
+    }
+  };
+}
+function createGetWebIdeChecklistTool(options) {
+  const { boundTaskId, webideGetChecklist } = options;
+  return {
+    GetWebIdeChecklist: {
+      description: "Fetch the acceptance checklist markdown for a WebIDE task by taskId. Returns content=null if none has been written yet. Use when you need to read or revise an existing checklist.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          taskId: {
+            type: "string",
+            description: "WebIDE task id whose checklist to load"
+          }
+        },
+        required: ["taskId"]
+      },
+      execute: async (args) => {
+        const taskId = asString(args.taskId);
+        if (!taskId) {
+          throw new Error("GetWebIdeChecklist \u7F3A\u5C11 taskId");
+        }
+        if (taskId !== boundTaskId) {
+          throw new Error(
+            `GetWebIdeChecklist \u7684 taskId \u987B\u4E3A\u5F53\u524D\u4EFB\u52A1 ${boundTaskId}`
+          );
+        }
+        const result = await webideGetChecklist({ taskId });
+        return JSON.stringify(result, null, 2);
+      }
+    }
+  };
+}
 
 // src/commands/connect/tools/webide-test-case-tools.ts
 function asString2(value) {
@@ -1618,7 +1600,7 @@ function createUpsertWebIdeTestCasesTool(options) {
   const { webideReplaceTestCases } = options;
   return {
     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.",
+      description: "Persist generated automated test cases for this WebIDE task (full replace). Call once with the complete case list after reviewing the task and code changes. Does not change workflow phase.",
       inputSchema: {
         type: "object",
         properties: {
@@ -2364,6 +2346,23 @@ function createCursorCustomTools(cfg2, options) {
         })
       );
     }
+    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,
@@ -3138,14 +3137,75 @@ function createThrottledWebIdeMessageLogSync(cfg2, ctx, onError, options) {
   };
 }
 
-// src/commands/init.ts
-async function initializeWorkspace(workdir) {
-  await ensureWorkspaceApmDirForInit(workdir);
+// src/commands/sync-webide-agent.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+var REVISION_FILE = ".webide-agent.json";
+var RULE_KEY = /^webide_[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);
-  await copyWebIdeTemplateFiles(apmDir, workdir);
-  console.log(`[apm] \u5DF2\u6309 WebIDE \u521D\u59CB\u5316\u5DE5\u4F5C\u533A\uFF1A${apmDir}`);
-  return { didInit: true };
+  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"
+  );
+  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)"}`);
+    }
+    writeFileSync3(
+      toFsPath(join4(rulesDir, `${key}.md`)),
+      withTrailingNewline(rule.body ?? ""),
+      "utf8"
+    );
+  }
+  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 };
@@ -3153,19 +3213,21 @@ async function ensureWorkspaceInitialized(workdir) {
   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`
   );
-  return initializeWorkspace(workdir);
+  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 existsSync5,
+  existsSync as existsSync6,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   rmSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { dirname as dirname3, join as join4, relative as relative4, sep } from "path";
+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();
@@ -3179,11 +3241,11 @@ function normalizeProjectIdForPath(projectId) {
 }
 function projectDocumentsDir(apmRoot, projectId) {
   const id = normalizeProjectIdForPath(projectId);
-  return join4(apmRoot ?? workspaceApmDir(), "project", id);
+  return join5(apmRoot ?? workspaceApmDir(), "project", id);
 }
 function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
-  return join4(
+  return join5(
     projectDocumentsDir(apmRoot, projectId),
     ...normalized.split("/")
   );
@@ -3203,16 +3265,16 @@ function hashLocalFileContent(content) {
   return createHash2("sha256").update(content, "utf8").digest("hex");
 }
 function readLocalManifest(apmRoot, projectId) {
-  const manifestPath3 = join4(
+  const manifestPath2 = join5(
     projectDocumentsDir(apmRoot, projectId),
     MANIFEST_FILE
   );
-  if (!existsSync5(manifestPath3)) {
+  if (!existsSync6(manifestPath2)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync4(manifestPath3, "utf8")
+      readFileSync5(manifestPath2, "utf8")
     );
   } catch {
     return null;
@@ -3220,13 +3282,13 @@ function readLocalManifest(apmRoot, projectId) {
 }
 function listLocalDocumentPaths(apmRoot, projectId) {
   const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync5(root)) {
+  if (!existsSync6(root)) {
     return [];
   }
   const paths = [];
   const walk = (dir) => {
     for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const abs = join4(dir, entry.name);
+      const abs = join5(dir, entry.name);
       if (entry.isDirectory()) {
         walk(abs);
         continue;
@@ -3345,8 +3407,8 @@ ${diagnostic ?? ""}`);
       const absPath = toFsPath(
         projectDocumentLocalPath(targetApmDir, projectId, doc.path)
       );
-      await ensureDirExists(dirname3(absPath));
-      writeFileSync3(absPath, doc.content, "utf8");
+      await ensureDirExists(dirname2(absPath));
+      writeFileSync4(absPath, doc.content, "utf8");
       downloaded += 1;
     }
   }
@@ -3355,13 +3417,13 @@ ${diagnostic ?? ""}`);
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path3)
     );
-    if (existsSync5(absPath)) {
+    if (existsSync6(absPath)) {
       rmSync(absPath, { force: true });
       deleted += 1;
     }
   }
-  writeFileSync3(
-    toFsPath(join4(docsDir, MANIFEST_FILE)),
+  writeFileSync4(
+    toFsPath(join5(docsDir, MANIFEST_FILE)),
     `${JSON.stringify(remoteManifest, null, 2)}
 `,
     "utf8"
@@ -3404,7 +3466,7 @@ async function syncProjectDocumentsPush(cfg2, workdirPath, apmRoot, options) {
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path3)
     );
-    const content = readFileSync4(absPath, "utf8");
+    const content = readFileSync5(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
     if (remoteHashByPath.get(path3) === contentHash) {
       continue;
@@ -3424,71 +3486,6 @@ async function syncProjectDocumentsPush(cfg2, workdirPath, apmRoot, options) {
   return synced;
 }
 
-// src/version.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname4, join as join5 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function readCliVersion() {
-  try {
-    const dir = dirname4(fileURLToPath2(import.meta.url));
-    const pkgPath = join5(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
-// src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join6 } from "path";
-var CLI_VERSION_FILE = ".cli-version.json";
-function manifestPath2(apmDir) {
-  return join6(apmDir, CLI_VERSION_FILE);
-}
-function loadManifest(apmDir) {
-  const path3 = toFsPath(manifestPath2(apmDir));
-  if (!existsSync6(path3)) {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(
-      readFileSync6(path3, "utf8")
-    );
-    if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
-      return parsed;
-    }
-  } catch {
-  }
-  return null;
-}
-function saveManifest(apmDir, cliVersion) {
-  const manifest = { version: 1, cliVersion };
-  writeFileSync4(
-    toFsPath(manifestPath2(apmDir)),
-    `${JSON.stringify(manifest, null, 2)}
-`,
-    "utf8"
-  );
-}
-var syncedInSession = /* @__PURE__ */ new Map();
-function shouldSyncSkillsForCliVersion(workdir, currentVersion) {
-  const cached = syncedInSession.get(workdir);
-  if (cached === currentVersion) {
-    return false;
-  }
-  const stored = loadManifest(workspaceApmDir(workdir));
-  if (stored?.cliVersion === currentVersion) {
-    syncedInSession.set(workdir, currentVersion);
-    return false;
-  }
-  return true;
-}
-function markSkillsSyncedForCliVersion(workdir, cliVersion) {
-  saveManifest(workspaceApmDir(workdir), cliVersion);
-  syncedInSession.set(workdir, cliVersion);
-}
-
 // src/commands/connect/upload-package-artifact.ts
 import fs2 from "node:fs";
 import path2 from "node:path";
@@ -3608,26 +3605,12 @@ async function handleWebIdePackage(cfg2, msg2, signal) {
       },
       (didInit) => didInit ? "\u5DF2\u521D\u59CB\u5316\u5DE5\u4F5C\u533A" : "\u5DE5\u4F5C\u533A\u5DF2\u5C31\u7EEA"
     );
-    const cliVersion = readCliVersion();
-    if (shouldSyncSkillsForCliVersion(workdir, cliVersion)) {
-      if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
-      await runPrepStep(
-        "\u540C\u6B65 WebIDE \u89C4\u5219",
-        async () => {
-          await copyWebIdeTemplateFiles(workspaceApmDir(workdir), workdir);
-          markSkillsSyncedForCliVersion(workdir, cliVersion);
-          return cliVersion;
-        },
-        (version) => `\u5DF2\u540C\u6B65\u81F3 CLI ${version}`
-      );
-    } else {
-      eventSession.addCliStep(
-        "\u540C\u6B65 WebIDE \u89C4\u5219",
-        `\u7248\u672C\u4E00\u81F4\uFF08${cliVersion}\uFF09\uFF0C\u8DF3\u8FC7`,
-        "skip"
-      );
-      await syncPrepLog();
-    }
+    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 () => {
@@ -3856,6 +3839,7 @@ async function handleStartProject(cfg2, msg2, signal) {
   try {
     if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
     await ensureWorkspaceInitialized(workdir);
+    await syncWebIdeAgentFiles(workdir, cfg2);
     const api = createApmApiClient(cfg2);
     const outcome = await runCursorAgent(
       cfg2,
@@ -3967,8 +3951,8 @@ async function handleStartProject(cfg2, msg2, signal) {
 }
 
 // src/commands/connect/webide-agent-registry.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname5, resolve as resolve6 } from "node:path";
+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);
 }
@@ -3978,7 +3962,7 @@ function readRegistry(path3) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync7(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync6(path3, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const raw = parsed;
       const state = {};
@@ -4007,7 +3991,7 @@ function readRegistry(path3) {
   return {};
 }
 function writeRegistry(path3, registry) {
-  mkdirSync4(dirname5(path3), { recursive: true });
+  mkdirSync5(dirname3(path3), { recursive: true });
   writeFileSync5(path3, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
@@ -4145,100 +4129,6 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
   }
 }
 
-// src/commands/connect/webide-run-action.ts
-function startActionForInbound(action) {
-  switch (action) {
-    case "request-assessment":
-      return "start-assessment";
-    case "request-design":
-    case "request-revise-design":
-      return "start-design";
-    case "request-write-plan":
-    case "request-revise-plan":
-      return "start-write-plan";
-    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":
-      return "start-bugfix";
-    case "request-organize-code":
-    case "request-patch":
-      return "start-organize-code";
-    case "request-accept":
-      return "start-accept";
-    default:
-      return null;
-  }
-}
-function completeActionForInbound(action) {
-  switch (action) {
-    case "request-assessment":
-    case "confirm-assumptions":
-      return "complete-assessment";
-    case "request-design":
-    case "request-revise-design":
-      return "complete-design";
-    case "request-write-plan":
-    case "request-revise-plan":
-      return "complete-write-plan";
-    case "request-develop":
-    case "skip-plan":
-      return "complete-develop";
-    case "request-start-project":
-      return "complete-project";
-    case "request-execute-sql":
-      return "complete-execute-sql";
-    case "request-bugfix":
-      return "complete-bugfix";
-    case "request-organize-code":
-    case "request-patch":
-      return "complete-organize-code";
-    case "request-accept":
-      return "complete-accept";
-    default:
-      return null;
-  }
-}
-async function webIdeRunAction(cfg2, taskId, action, params) {
-  const api = createApmApiClient(cfg2);
-  await api.cli.webideRunAction({ taskId, action, params });
-  console.log(`[apm] webide runAction ok action=${action} taskId=${taskId}`);
-}
-async function webIdeSyncTransitionPrepEvents(cfg2, taskId, startAction, prepEvents) {
-  try {
-    const api = createApmApiClient(cfg2);
-    await api.cli.webideUpdateTransitionPrepEvents({
-      taskId,
-      startAction,
-      prepEvents
-    });
-  } catch (err) {
-    console.warn(
-      `[apm] sync transition prepEvents failed taskId=${taskId}:`,
-      err instanceof Error ? err.message : err
-    );
-  }
-}
-async function webIdeDiscardTransitionPrepDraft(cfg2, taskId, startAction) {
-  try {
-    const api = createApmApiClient(cfg2);
-    await api.cli.webideUpdateTransitionPrepEvents({
-      taskId,
-      startAction,
-      discardDraft: true
-    });
-  } catch (err) {
-    console.warn(
-      `[apm] discard transition prep draft failed taskId=${taskId}:`,
-      err instanceof Error ? err.message : err
-    );
-  }
-}
-
 // src/commands/connect/webide-ask-question.ts
 function asString5(value) {
   return typeof value === "string" ? value.trim() : "";
@@ -4298,9 +4188,8 @@ async function fetchAssumptionAnswersAndContinueAssessment(options) {
       resolution: row.resolution
     });
   }
-  await webIdeRunAction(cfg2, taskId, "continue-assessment");
   console.log(
-    `[apm] \u5047\u8BBE\u7ED3\u679C\u5DF2\u62C9\u53D6\u5E76\u7EE7\u7EED\u8BC4\u4F30 taskId=${taskId} count=${answers.length}`
+    `[apm] \u5047\u8BBE\u7ED3\u679C\u5DF2\u62C9\u53D6 taskId=${taskId} count=${answers.length}`
   );
   return JSON.stringify({ title, answers }, null, 2);
 }
@@ -4554,8 +4443,8 @@ async function ensureWebIdePullRequests(cfg2, taskId, workdir) {
 }
 
 // src/commands/sync-webide-attachments.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
-import { join as join7 } from "path";
+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(/\/+$/, "");
@@ -4570,14 +4459,14 @@ async function downloadAttachment(cfg2, attachmentId) {
   }
   return Buffer.from(await res.arrayBuffer());
 }
-function loadManifest2(dir) {
-  const path3 = join7(dir, MANIFEST_FILE2);
+function loadManifest(dir) {
+  const path3 = join6(dir, MANIFEST_FILE2);
   if (!existsSync9(path3)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync8(path3, "utf8")
+      readFileSync7(path3, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -4586,9 +4475,9 @@ function loadManifest2(dir) {
   }
   return { version: 1, attachments: {} };
 }
-function saveManifest2(dir, manifest) {
+function saveManifest(dir, manifest) {
   writeFileSync6(
-    join7(dir, MANIFEST_FILE2),
+    join6(dir, MANIFEST_FILE2),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
@@ -4603,14 +4492,14 @@ function isAttachmentUpToDate(entry, item, dest) {
 async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
   await ensureDirExists(dir);
   if (attachments.length === 0) {
-    saveManifest2(dir, { version: 1, attachments: {} });
+    saveManifest(dir, { version: 1, attachments: {} });
     return [];
   }
-  const manifest = loadManifest2(dir);
+  const manifest = loadManifest(dir);
   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);
@@ -4627,7 +4516,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
     };
     console.log(`[apm] \u5DF2\u4E0B\u8F7D\u9644\u4EF6: ${logLabel}/${item.name}`);
   }
-  saveManifest2(dir, nextManifest);
+  saveManifest(dir, nextManifest);
   return names;
 }
 async function syncWebIdeAttachments(cfg2, taskId, workdir, attachments) {
@@ -4642,19 +4531,19 @@ async function syncWebIdeAttachments(cfg2, taskId, workdir, attachments) {
 
 // src/commands/sync-webide-design.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join7 } from "path";
 var MANIFEST_FILE3 = ".sync-manifest.json";
 function hashBuffer(buf) {
   return createHash3("sha256").update(buf).digest("hex");
 }
-function loadManifest3(dir) {
-  const path3 = join8(dir, MANIFEST_FILE3);
+function loadManifest2(dir) {
+  const path3 = join7(dir, MANIFEST_FILE3);
   if (!existsSync10(path3)) {
     return { version: 1, files: {} };
   }
   try {
-    const parsed = JSON.parse(readFileSync9(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path3, "utf8"));
     if (parsed?.version === 1 && parsed.files && typeof parsed.files === "object") {
       return parsed;
     }
@@ -4662,9 +4551,9 @@ function loadManifest3(dir) {
   }
   return { version: 1, files: {} };
 }
-function saveManifest3(dir, manifest) {
+function saveManifest2(dir, manifest) {
   writeFileSync7(
-    join8(dir, MANIFEST_FILE3),
+    join7(dir, MANIFEST_FILE3),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
@@ -4687,12 +4576,12 @@ async function downloadDesignFile(cfg2, taskId, name) {
 async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
   const dir = webideDesignDir(taskId, workdir);
   await ensureDirExists(dir);
-  const manifest = loadManifest3(dir);
+  const manifest = loadManifest2(dir);
   const synced = [];
   for (const art of artifacts) {
     const name = art.name?.trim();
     if (!name || !name.toLowerCase().endsWith(".html")) continue;
-    const localPath = join8(dir, name);
+    const localPath = join7(dir, name);
     const entry = manifest.files[name];
     if (entry?.contentHash === art.contentHash && existsSync10(localPath)) {
       continue;
@@ -4702,7 +4591,7 @@ async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
     manifest.files[name] = { contentHash: hashBuffer(buf) };
     synced.push(name);
   }
-  saveManifest3(dir, manifest);
+  saveManifest2(dir, manifest);
   return synced;
 }
 function listLocalDesignHtmlFiles(taskId, workdir) {
@@ -4711,8 +4600,8 @@ function listLocalDesignHtmlFiles(taskId, workdir) {
   const out = [];
   for (const name of readdirSync4(dir)) {
     if (!name.toLowerCase().endsWith(".html")) continue;
-    const absPath = join8(dir, name);
-    const buf = readFileSync9(absPath);
+    const absPath = join7(dir, name);
+    const buf = readFileSync8(absPath);
     if (buf.length === 0) continue;
     out.push({ name, absPath, contentHash: hashBuffer(buf) });
   }
@@ -4790,6 +4679,102 @@ function parseWebIdePromptPayload(content) {
   return null;
 }
 
+// src/commands/connect/webide-run-action.ts
+function startActionForInbound(action) {
+  switch (action) {
+    case "request-assessment":
+      return "start-assessment";
+    case "request-design":
+    case "request-revise-design":
+      return "start-design";
+    case "request-write-plan":
+    case "request-revise-plan":
+      return "start-write-plan";
+    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":
+      return "start-bugfix";
+    case "request-organize-code":
+    case "request-patch":
+      return "start-organize-code";
+    case "request-accept":
+      return "start-accept";
+    case "confirm-assumptions":
+      return "continue-assessment";
+    default:
+      return null;
+  }
+}
+function completeActionForInbound(action) {
+  switch (action) {
+    case "request-assessment":
+    case "confirm-assumptions":
+      return "complete-assessment";
+    case "request-design":
+    case "request-revise-design":
+      return "complete-design";
+    case "request-write-plan":
+    case "request-revise-plan":
+      return "complete-write-plan";
+    case "request-develop":
+    case "skip-plan":
+      return "complete-develop";
+    case "request-start-project":
+      return "complete-project";
+    case "request-execute-sql":
+      return "complete-execute-sql";
+    case "request-bugfix":
+      return "complete-bugfix";
+    case "request-organize-code":
+    case "request-patch":
+      return "complete-organize-code";
+    case "request-accept":
+      return "complete-accept";
+    default:
+      return null;
+  }
+}
+async function webIdeRunAction(cfg2, taskId, action, params) {
+  const api = createApmApiClient(cfg2);
+  await api.cli.webideRunAction({ taskId, action, params });
+  console.log(`[apm] webide runAction ok action=${action} taskId=${taskId}`);
+}
+async function webIdeSyncTransitionPrepEvents(cfg2, taskId, startAction, prepEvents) {
+  try {
+    const api = createApmApiClient(cfg2);
+    await api.cli.webideUpdateTransitionPrepEvents({
+      taskId,
+      startAction,
+      prepEvents
+    });
+  } catch (err) {
+    console.warn(
+      `[apm] sync transition prepEvents failed taskId=${taskId}:`,
+      err instanceof Error ? err.message : err
+    );
+  }
+}
+async function webIdeDiscardTransitionPrepDraft(cfg2, taskId, startAction) {
+  try {
+    const api = createApmApiClient(cfg2);
+    await api.cli.webideUpdateTransitionPrepEvents({
+      taskId,
+      startAction,
+      discardDraft: true
+    });
+  } catch (err) {
+    console.warn(
+      `[apm] discard transition prep draft failed taskId=${taskId}:`,
+      err instanceof Error ? err.message : err
+    );
+  }
+}
+
 // src/commands/connect/core/worker/handlers/webide-message.ts
 var WEBIDE_CODE_CHANGE_ACTIONS = /* @__PURE__ */ new Set([
   "skip-plan",
@@ -4899,26 +4884,12 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
       },
       (didInit) => didInit ? "\u5DF2\u521D\u59CB\u5316\u5DE5\u4F5C\u533A" : "\u5DE5\u4F5C\u533A\u5DF2\u5C31\u7EEA"
     );
-    const cliVersion = readCliVersion();
-    if (shouldSyncSkillsForCliVersion(workdir, cliVersion)) {
-      if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
-      await runPrepStep(
-        "\u540C\u6B65 WebIDE \u89C4\u5219",
-        async () => {
-          await copyWebIdeTemplateFiles(workspaceApmDir(workdir), workdir);
-          markSkillsSyncedForCliVersion(workdir, cliVersion);
-          return cliVersion;
-        },
-        (version) => `\u5DF2\u540C\u6B65\u81F3 CLI ${version}`
-      );
-    } else {
-      eventSession.addCliStep(
-        "\u540C\u6B65 WebIDE \u89C4\u5219",
-        `\u7248\u672C\u4E00\u81F4\uFF08${cliVersion}\uFF09\uFF0C\u8DF3\u8FC7`,
-        "skip"
-      );
-      await syncPrepLog();
-    }
+    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 () => {