ai-project-manage-cli 8.1.12 → 8.1.14

package/dist/index.js

@@ -133,6 +133,11 @@ var requestConfig = {
       method: "PUT",
       path: "/cli/webide/transition-prep-events"
     }),
+    /** 「继续」开跑后挂新 runId */
+    webideAttachContinueRun: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/continue-run"
+    }),
     webideUpsertMessageLog: defineEndpoint({
       method: "PUT",
       path: "/cli/webide/message-logs"

package/dist/worker-script.js

@@ -44,6 +44,11 @@ var requestConfig = {
       method: "PUT",
       path: "/cli/webide/transition-prep-events"
     }),
+    /** 「继续」开跑后挂新 runId */
+    webideAttachContinueRun: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/continue-run"
+    }),
     webideUpsertMessageLog: defineEndpoint({
       method: "PUT",
       path: "/cli/webide/message-logs"
@@ -2468,10 +2473,76 @@ function createPtySessionMcpServers(cfg2) {
 }
 
 // src/commands/connect/remote-local-agent-store.ts
+import { createHash as createHash2 } from "node:crypto";
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  rmSync,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
 var INLINE_CHECKPOINT_MAX_BYTES = 256 * 1024;
+var CHECKPOINT_CACHE_DIR = join4(APM_CONFIG_DIR, "cursor-checkpoint-cache");
 function checkpointObjectKey(agentId, blobId) {
   return `cursor-agents/${agentId}/checkpoints/${blobId}`;
 }
+function safeBlobFileName(blobId) {
+  if (/^[a-zA-Z0-9._-]+$/.test(blobId)) return blobId;
+  return createHash2("sha256").update(blobId).digest("hex");
+}
+function checkpointCachePath(agentId, blobId) {
+  return join4(CHECKPOINT_CACHE_DIR, agentId, safeBlobFileName(blobId));
+}
+function checkpointCacheKey(agentId, blobId) {
+  return `${agentId}\0${blobId}`;
+}
+function readLocalCheckpoint(agentId, blobId) {
+  try {
+    const path3 = checkpointCachePath(agentId, blobId);
+    if (!existsSync5(path3)) return null;
+    return new Uint8Array(readFileSync4(path3));
+  } catch {
+    return null;
+  }
+}
+function writeLocalCheckpoint(agentId, blobId, data) {
+  try {
+    const path3 = checkpointCachePath(agentId, blobId);
+    mkdirSync4(dirname2(path3), { recursive: true });
+    writeFileSync3(path3, Buffer.from(data));
+  } catch (err) {
+    console.warn(
+      `[apm] checkpoint \u672C\u5730\u7F13\u5B58\u5199\u5165\u5931\u8D25 agentId=${agentId} blobId=${blobId}:`,
+      err instanceof Error ? err.message : err
+    );
+  }
+}
+function deleteLocalCheckpoint(agentId, blobId) {
+  try {
+    const path3 = checkpointCachePath(agentId, blobId);
+    if (existsSync5(path3)) unlinkSync(path3);
+  } catch {
+  }
+}
+function clearLocalCheckpointCache(agentId) {
+  try {
+    if (agentId?.trim()) {
+      const dir = join4(CHECKPOINT_CACHE_DIR, agentId.trim());
+      if (existsSync5(dir)) rmSync(dir, { recursive: true, force: true });
+      return;
+    }
+    if (existsSync5(CHECKPOINT_CACHE_DIR)) {
+      rmSync(CHECKPOINT_CACHE_DIR, { recursive: true, force: true });
+    }
+  } catch (err) {
+    console.warn(
+      `[apm] \u6E05\u7406 checkpoint \u672C\u5730\u7F13\u5B58\u5931\u8D25:`,
+      err instanceof Error ? err.message : err
+    );
+  }
+}
 function asCheckpointRef(value) {
   if (value === void 0) return void 0;
   if (value === null) return null;
@@ -2544,9 +2615,16 @@ function bytesToBase64(data) {
 function base64ToBytes(dataBase64) {
   return new Uint8Array(Buffer.from(dataBase64, "base64"));
 }
+var pendingCheckpointUploads = /* @__PURE__ */ new Map();
+async function flushPendingCheckpointUploads() {
+  const pending2 = [...pendingCheckpointUploads.values()];
+  if (pending2.length === 0) return;
+  await Promise.allSettled(pending2);
+}
 function createRemoteLocalAgentStore(cfg2) {
   const api = createApmApiClient(cfg2);
   let minioCache = null;
+  const memoryCheckpointCache = /* @__PURE__ */ new Map();
   function getMinio() {
     if (!minioCache) {
       minioCache = createApmLogMinioClient(cfg2).then(({ client, bucket }) => ({
@@ -2556,6 +2634,14 @@ function createRemoteLocalAgentStore(cfg2) {
     }
     return minioCache;
   }
+  function rememberCheckpoint(agentId, blobId, data) {
+    memoryCheckpointCache.set(checkpointCacheKey(agentId, blobId), data);
+    writeLocalCheckpoint(agentId, blobId, data);
+  }
+  function forgetCheckpoint(agentId, blobId) {
+    memoryCheckpointCache.delete(checkpointCacheKey(agentId, blobId));
+    deleteLocalCheckpoint(agentId, blobId);
+  }
   async function upsertAgent(agent) {
     const row = await api.cli.cursorStoreUpsertAgent({
       agentId: agent.agentId,
@@ -2591,7 +2677,7 @@ function createRemoteLocalAgentStore(cfg2) {
     });
     return fromApiRun(row);
   }
-  async function putCheckpoint(input) {
+  async function uploadCheckpointRemote(input) {
     const createdAt = Date.now();
     if (input.data.byteLength > INLINE_CHECKPOINT_MAX_BYTES) {
       const { client, bucket } = await getMinio();
@@ -2616,20 +2702,56 @@ function createRemoteLocalAgentStore(cfg2) {
       createdAt
     });
   }
+  async function putCheckpoint(input) {
+    const data = new Uint8Array(input.data);
+    rememberCheckpoint(input.agentId, input.blobId, data);
+    const key = checkpointCacheKey(input.agentId, input.blobId);
+    if (pendingCheckpointUploads.has(key)) return;
+    const startedAt = Date.now();
+    const uploadPromise = uploadCheckpointRemote({
+      agentId: input.agentId,
+      blobId: input.blobId,
+      data
+    }).then(() => {
+      console.log(
+        `[apm] checkpoint \u8FDC\u7A0B\u4E0A\u4F20\u5B8C\u6210 agentId=${input.agentId} blobId=${input.blobId} bytes=${data.byteLength} ms=${Date.now() - startedAt}`
+      );
+    }).catch((err) => {
+      console.warn(
+        `[apm] checkpoint \u8FDC\u7A0B\u4E0A\u4F20\u5931\u8D25\uFF08\u672C\u5730\u5DF2\u7F13\u5B58\uFF09 agentId=${input.agentId} blobId=${input.blobId}:`,
+        err instanceof Error ? err.message : err
+      );
+    }).finally(() => {
+      pendingCheckpointUploads.delete(key);
+    });
+    pendingCheckpointUploads.set(key, uploadPromise);
+  }
   async function readCheckpointBytes(input) {
+    const memKey = checkpointCacheKey(input.agentId, input.blobId);
+    const cached = memoryCheckpointCache.get(memKey);
+    if (cached) return cached;
+    const local = readLocalCheckpoint(input.agentId, input.blobId);
+    if (local) {
+      memoryCheckpointCache.set(memKey, local);
+      return local;
+    }
     const row = await api.cli.cursorStoreGetCheckpoint({
       agentId: input.agentId,
       blobId: input.blobId
     });
     if (!row) return null;
+    let bytes = null;
     if (row.dataBase64) {
-      return base64ToBytes(row.dataBase64);
+      bytes = base64ToBytes(row.dataBase64);
+    } else {
+      const objectKey = row.objectKey?.trim();
+      if (!objectKey) return null;
+      const { client, bucket } = await getMinio();
+      const buf = await client.getObjectBuffer(bucket, objectKey);
+      bytes = new Uint8Array(buf);
     }
-    const objectKey = row.objectKey?.trim();
-    if (!objectKey) return null;
-    const { client, bucket } = await getMinio();
-    const buf = await client.getObjectBuffer(bucket, objectKey);
-    return new Uint8Array(buf);
+    rememberCheckpoint(input.agentId, input.blobId, bytes);
+    return bytes;
   }
   return {
     agents: {
@@ -2798,6 +2920,23 @@ function createRemoteLocalAgentStore(cfg2) {
         const blobIds = input.filter.blobIds?.map((id) => id.trim()).filter(Boolean);
         if (agentIds && agentIds.length > 0 || blobIds && blobIds.length > 0) {
           await api.cli.cursorStoreDeleteCheckpoints({ agentIds, blobIds });
+          if (agentIds && agentIds.length > 0 && !blobIds?.length) {
+            for (const id of agentIds) clearLocalCheckpointCache(id);
+          } else if (agentIds && blobIds) {
+            for (const id of agentIds) {
+              for (const blobId of blobIds) forgetCheckpoint(id, blobId);
+            }
+          } else if (blobIds) {
+            for (const blobId of blobIds) {
+              for (const key of memoryCheckpointCache.keys()) {
+                const sep2 = key.indexOf("\0");
+                if (sep2 < 0) continue;
+                if (key.slice(sep2 + 1) === blobId) {
+                  forgetCheckpoint(key.slice(0, sep2), blobId);
+                }
+              }
+            }
+          }
           return;
         }
         let cursor;
@@ -2814,6 +2953,8 @@ function createRemoteLocalAgentStore(cfg2) {
           if (!page.nextCursor) break;
           cursor = page.nextCursor;
         }
+        clearLocalCheckpointCache();
+        memoryCheckpointCache.clear();
       },
       async list(input) {
         const page = await api.cli.cursorStoreListCheckpoints({
@@ -3228,14 +3369,14 @@ function createThrottledWebIdeMessageLogSync(cfg2, ctx, onError, options) {
 
 // src/commands/sync-webide-agent.ts
 import {
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync4,
-  unlinkSync,
-  writeFileSync as writeFileSync3
+  readFileSync as readFileSync5,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 var REVISION_FILE = ".webide-agent.json";
 var RULE_KEY = /^[a-z0-9_]+$/;
 function withTrailingNewline(text) {
@@ -3243,10 +3384,10 @@ function withTrailingNewline(text) {
 `;
 }
 function readRevision(apmDir) {
-  const path3 = toFsPath(join4(apmDir, REVISION_FILE));
-  if (!existsSync5(path3)) return null;
+  const path3 = toFsPath(join5(apmDir, REVISION_FILE));
+  if (!existsSync6(path3)) return null;
   try {
-    const parsed = JSON.parse(readFileSync4(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path3, "utf8"));
     if (parsed?.version === 1 && parsed.revision?.trim()) {
       return parsed.revision.trim();
     }
@@ -3256,8 +3397,8 @@ function readRevision(apmDir) {
   return null;
 }
 function writeRevision(apmDir, revision) {
-  writeFileSync3(
-    toFsPath(join4(apmDir, REVISION_FILE)),
+  writeFileSync4(
+    toFsPath(join5(apmDir, REVISION_FILE)),
     `${JSON.stringify({ version: 1, revision }, null, 2)}
 `,
     "utf8"
@@ -3271,14 +3412,14 @@ async function syncWebIdeAgentFiles(workdir, cfg2) {
     throw new Error("[apm] \u5E73\u53F0\u672A\u8FD4\u56DE WebIDE \u89C4\u5219\u7248\u672C");
   }
   const apmDir = workspaceApmDir(workdir);
-  mkdirSync4(toFsPath(apmDir), { recursive: true });
+  mkdirSync5(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")),
+  const rulesDir = join5(apmDir, "rules");
+  mkdirSync5(toFsPath(rulesDir), { recursive: true });
+  writeFileSync4(
+    toFsPath(join5(apmDir, "AGENTS.md")),
     withTrailingNewline(bundle.guide ?? ""),
     "utf8"
   );
@@ -3289,8 +3430,8 @@ async function syncWebIdeAgentFiles(workdir, cfg2) {
       throw new Error(`[apm] \u975E\u6CD5\u89C4\u5219\u540D: ${key || "(\u7A7A)"}`);
     }
     keep.add(`${key}.md`);
-    writeFileSync3(
-      toFsPath(join4(rulesDir, `${key}.md`)),
+    writeFileSync4(
+      toFsPath(join5(rulesDir, `${key}.md`)),
       withTrailingNewline(rule.body ?? ""),
       "utf8"
     );
@@ -3298,7 +3439,7 @@ async function syncWebIdeAgentFiles(workdir, cfg2) {
   for (const name of readdirSync3(toFsPath(rulesDir))) {
     if (!name.endsWith(".md")) continue;
     if (keep.has(name)) continue;
-    unlinkSync(toFsPath(join4(rulesDir, name)));
+    unlinkSync2(toFsPath(join5(rulesDir, name)));
   }
   writeRevision(apmDir, revision);
   return {
@@ -3323,14 +3464,14 @@ async function ensureWorkspaceInitialized(workdir) {
 
 // src/utils/project-documents.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync5,
-  rmSync,
-  writeFileSync as writeFileSync4
+  readFileSync as readFileSync6,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync5
 } from "fs";
-import { createHash as createHash2 } from "crypto";
-import { dirname as dirname2, join as join5, relative as relative4, sep } from "path";
+import { createHash as createHash3 } from "crypto";
+import { dirname as dirname3, join as join6, relative as relative4, sep } from "path";
 var MANIFEST_FILE = "manifest.json";
 function normalizeProjectIdForPath(projectId) {
   const id = projectId.trim();
@@ -3344,11 +3485,11 @@ function normalizeProjectIdForPath(projectId) {
 }
 function projectDocumentsDir(apmRoot, projectId) {
   const id = normalizeProjectIdForPath(projectId);
-  return join5(apmRoot ?? workspaceApmDir(), "project", id);
+  return join6(apmRoot ?? workspaceApmDir(), "project", id);
 }
 function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
-  return join5(
+  return join6(
     projectDocumentsDir(apmRoot, projectId),
     ...normalized.split("/")
   );
@@ -3365,19 +3506,19 @@ function normalizeLocalDocumentPath(path3) {
   return segments.join("/");
 }
 function hashLocalFileContent(content) {
-  return createHash2("sha256").update(content, "utf8").digest("hex");
+  return createHash3("sha256").update(content, "utf8").digest("hex");
 }
 function readLocalManifest(apmRoot, projectId) {
-  const manifestPath2 = join5(
+  const manifestPath2 = join6(
     projectDocumentsDir(apmRoot, projectId),
     MANIFEST_FILE
   );
-  if (!existsSync6(manifestPath2)) {
+  if (!existsSync7(manifestPath2)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync5(manifestPath2, "utf8")
+      readFileSync6(manifestPath2, "utf8")
     );
   } catch {
     return null;
@@ -3385,13 +3526,13 @@ function readLocalManifest(apmRoot, projectId) {
 }
 function listLocalDocumentPaths(apmRoot, projectId) {
   const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync6(root)) {
+  if (!existsSync7(root)) {
     return [];
   }
   const paths = [];
   const walk = (dir) => {
     for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-      const abs = join5(dir, entry.name);
+      const abs = join6(dir, entry.name);
       if (entry.isDirectory()) {
         walk(abs);
         continue;
@@ -3510,8 +3651,8 @@ ${diagnostic ?? ""}`);
       const absPath = toFsPath(
         projectDocumentLocalPath(targetApmDir, projectId, doc.path)
       );
-      await ensureDirExists(dirname2(absPath));
-      writeFileSync4(absPath, doc.content, "utf8");
+      await ensureDirExists(dirname3(absPath));
+      writeFileSync5(absPath, doc.content, "utf8");
       downloaded += 1;
     }
   }
@@ -3520,13 +3661,13 @@ ${diagnostic ?? ""}`);
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path3)
     );
-    if (existsSync6(absPath)) {
-      rmSync(absPath, { force: true });
+    if (existsSync7(absPath)) {
+      rmSync2(absPath, { force: true });
       deleted += 1;
     }
   }
-  writeFileSync4(
-    toFsPath(join5(docsDir, MANIFEST_FILE)),
+  writeFileSync5(
+    toFsPath(join6(docsDir, MANIFEST_FILE)),
     `${JSON.stringify(remoteManifest, null, 2)}
 `,
     "utf8"
@@ -3569,7 +3710,7 @@ async function syncProjectDocumentsPush(cfg2, workdirPath, apmRoot, options) {
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path3)
     );
-    const content = readFileSync5(absPath, "utf8");
+    const content = readFileSync6(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
     if (remoteHashByPath.get(path3) === contentHash) {
       continue;
@@ -4054,18 +4195,18 @@ async function handleStartProject(cfg2, msg2, signal) {
 }
 
 // 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";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname4, 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)) {
+  if (!existsSync8(path3)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync6(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path3, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const raw = parsed;
       const state = {};
@@ -4094,8 +4235,8 @@ function readRegistry(path3) {
   return {};
 }
 function writeRegistry(path3, registry) {
-  mkdirSync5(dirname3(path3), { recursive: true });
-  writeFileSync5(path3, `${JSON.stringify(registry, null, 2)}
+  mkdirSync6(dirname4(path3), { recursive: true });
+  writeFileSync6(path3, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function syncWebIdeTaskState(workdir, taskId, patch) {
@@ -4136,7 +4277,7 @@ function saveWebIdeAgentId(workdir, taskId, agentId) {
 }
 function clearWebIdeAgentId(workdir, taskId) {
   const path3 = registryPath(workdir, taskId);
-  if (!existsSync7(path3)) return;
+  if (!existsSync8(path3)) return;
   syncWebIdeTaskState(workdir, taskId, { agentId: "" });
 }
 function loadWebIdeDesignAgentId(workdir, taskId) {
@@ -4156,7 +4297,7 @@ function saveWebIdeDesignAgentId(workdir, taskId, agentId) {
 }
 function clearWebIdeDesignAgentId(workdir, taskId) {
   const path3 = registryPath(workdir, taskId, DESIGN_AGENT_FILE);
-  if (!existsSync7(path3)) return;
+  if (!existsSync8(path3)) return;
   const current = readRegistry(path3);
   const next = { ...current };
   delete next.agentId;
@@ -4168,11 +4309,12 @@ function clearWebIdeDesignAgentId(workdir, taskId) {
 }
 
 // src/commands/clean-webide-cache.ts
-import { existsSync as existsSync8, rmSync as rmSync2 } from "node:fs";
+import { existsSync as existsSync9, rmSync as rmSync3 } from "node:fs";
 import { resolve as resolve7 } from "node:path";
 async function purgeCursorAgentStoreForAgent(cfg2, agentId) {
   const trimmedAgentId = agentId.trim();
   if (!trimmedAgentId) return false;
+  await flushPendingCheckpointUploads();
   const store = createRemoteLocalAgentStore(cfg2);
   const runIds = [];
   let cursor;
@@ -4195,6 +4337,7 @@ async function purgeCursorAgentStoreForAgent(cfg2, agentId) {
   await store.runs.delete({ filter: { agentIds: [trimmedAgentId] } });
   await store.checkpoints.delete({ filter: { agentIds: [trimmedAgentId] } });
   await store.agents.delete({ filter: { agentIds: [trimmedAgentId] } });
+  clearLocalCheckpointCache(trimmedAgentId);
   return true;
 }
 async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
@@ -4224,8 +4367,8 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
     );
   }
   const dir = resolve7(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
-  if (existsSync8(dir)) {
-    rmSync2(dir, { recursive: true, force: true });
+  if (existsSync9(dir)) {
+    rmSync3(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}`);
@@ -4546,8 +4689,8 @@ async function ensureWebIdePullRequests(cfg2, taskId, workdir) {
 }
 
 // src/commands/sync-webide-attachments.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join7 } from "path";
 var MANIFEST_FILE2 = ".sync-manifest.json";
 async function downloadAttachment(cfg2, attachmentId) {
   const base = cfg2.baseUrl.trim().replace(/\/+$/, "");
@@ -4563,13 +4706,13 @@ async function downloadAttachment(cfg2, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path3 = join6(dir, MANIFEST_FILE2);
-  if (!existsSync9(path3)) {
+  const path3 = join7(dir, MANIFEST_FILE2);
+  if (!existsSync10(path3)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync7(path3, "utf8")
+      readFileSync8(path3, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -4579,15 +4722,15 @@ function loadManifest(dir) {
   return { version: 1, attachments: {} };
 }
 function saveManifest(dir, manifest) {
-  writeFileSync6(
-    join6(dir, MANIFEST_FILE2),
+  writeFileSync7(
+    join7(dir, MANIFEST_FILE2),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
 function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync9(dest)) return false;
+  if (!entry || !existsSync10(dest)) return false;
   if (entry.name !== item.name) return false;
   const createdAt = item.createdAt ?? "";
   return entry.createdAt === createdAt;
@@ -4602,7 +4745,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
   const nextManifest = { version: 1, attachments: {} };
   const names = [];
   for (const item of attachments) {
-    const dest = join6(dir, item.name);
+    const dest = join7(dir, item.name);
     const entry = manifest.attachments[item.id];
     const createdAt = item.createdAt ?? "";
     names.push(item.name);
@@ -4612,7 +4755,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
       continue;
     }
     const buffer = await downloadAttachment(cfg2, item.id);
-    writeFileSync6(dest, buffer);
+    writeFileSync7(dest, buffer);
     nextManifest.attachments[item.id] = {
       name: item.name,
       createdAt
@@ -4633,9 +4776,9 @@ async function syncWebIdeAttachments(cfg2, taskId, workdir, attachments) {
 }
 
 // src/commands/sync-webide-design.ts
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync5, writeFileSync as writeFileSync7 } from "fs";
-import { join as join7 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync9, statSync as statSync5, writeFileSync as writeFileSync8 } from "fs";
+import { join as join8 } from "path";
 
 // src/opc-shared-types.ts
 function webIdeDesignObjectKey(taskId, fileName) {
@@ -4653,15 +4796,15 @@ function webIdeDesignArtifactContentType(name) {
 // src/commands/sync-webide-design.ts
 var MANIFEST_FILE3 = ".sync-manifest.json";
 function hashBuffer(buf) {
-  return createHash3("sha256").update(buf).digest("hex");
+  return createHash4("sha256").update(buf).digest("hex");
 }
 function loadManifest2(dir) {
-  const path3 = join7(dir, MANIFEST_FILE3);
-  if (!existsSync10(path3)) {
+  const path3 = join8(dir, MANIFEST_FILE3);
+  if (!existsSync11(path3)) {
     return { version: 1, files: {} };
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path3, "utf8"));
     if (parsed?.version === 1 && parsed.files && typeof parsed.files === "object") {
       return parsed;
     }
@@ -4670,8 +4813,8 @@ function loadManifest2(dir) {
   return { version: 1, files: {} };
 }
 function saveManifest2(dir, manifest) {
-  writeFileSync7(
-    join7(dir, MANIFEST_FILE3),
+  writeFileSync8(
+    join8(dir, MANIFEST_FILE3),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
@@ -4699,13 +4842,13 @@ async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
   for (const art of artifacts) {
     const name = art.name?.trim();
     if (!name || !isWebIdeDesignArtifactName(name)) continue;
-    const localPath = join7(dir, name);
+    const localPath = join8(dir, name);
     const entry = manifest.files[name];
-    if (entry?.contentHash === art.contentHash && existsSync10(localPath)) {
+    if (entry?.contentHash === art.contentHash && existsSync11(localPath)) {
       continue;
     }
     const buf = await downloadDesignFile(cfg2, taskId, name);
-    writeFileSync7(localPath, buf);
+    writeFileSync8(localPath, buf);
     manifest.files[name] = { contentHash: hashBuffer(buf) };
     synced.push(name);
   }
@@ -4714,13 +4857,13 @@ async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
 }
 function listLocalDesignArtifactFiles(taskId, workdir) {
   const dir = webideDesignDir(taskId, workdir);
-  if (!existsSync10(dir)) return [];
+  if (!existsSync11(dir)) return [];
   const out = [];
   for (const name of readdirSync5(dir)) {
     if (!isWebIdeDesignArtifactName(name)) continue;
-    const absPath = join7(dir, name);
+    const absPath = join8(dir, name);
     if (!statSync5(absPath).isFile()) continue;
-    const buf = readFileSync8(absPath);
+    const buf = readFileSync9(absPath);
     if (buf.length === 0) continue;
     out.push({ name, absPath, contentHash: hashBuffer(buf) });
   }
@@ -4825,26 +4968,36 @@ function completeActionForInbound(action) {
   switch (action) {
     case "request-assessment":
     case "confirm-assumptions":
+    case "start-assessment":
+    case "continue-assessment":
       return "complete-assessment";
     case "request-design":
     case "request-revise-design":
+    case "start-design":
       return "complete-design";
     case "request-write-plan":
     case "request-revise-plan":
+    case "start-write-plan":
       return "complete-write-plan";
     case "request-develop":
     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";
     case "request-bugfix":
+    case "start-bugfix":
       return "complete-bugfix";
     case "request-organize-code":
     case "request-patch":
+    case "start-organize-code":
       return "complete-organize-code";
     case "request-accept":
+    case "start-accept":
       return "complete-accept";
     default:
       return null;
@@ -4855,6 +5008,13 @@ async function webIdeRunAction(cfg2, taskId, action, params) {
   await api.cli.webideRunAction({ taskId, action, params });
   console.log(`[apm] webide runAction ok action=${action} taskId=${taskId}`);
 }
+async function webIdeAttachContinueRun(cfg2, taskId, runId) {
+  const api = createApmApiClient(cfg2);
+  await api.cli.webideAttachContinueRun({ taskId, runId });
+  console.log(
+    `[apm] webide attachContinueRun ok runId=${runId} taskId=${taskId}`
+  );
+}
 async function webIdeSyncTransitionPrepEvents(cfg2, taskId, startAction, prepEvents) {
   try {
     const api = createApmApiClient(cfg2);
@@ -4927,8 +5087,11 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
   const messageId = msg2.messageId;
   const taskId = msg2.taskId;
   const branchCacheKey = taskId;
+  const continuePayload = msg2.action === "continue" ? parseWebIdePromptPayload(msg2.content) : null;
+  const previousAction = typeof continuePayload?.previousAction === "string" ? continuePayload.previousAction.trim() : "";
+  const effectiveAction = msg2.action === "continue" && previousAction ? previousAction : msg2.action;
   console.log(
-    `[apm] webide-message action=${msg2.action} taskId=${taskId} messageId=${messageId}`
+    `[apm] webide-message action=${msg2.action}${previousAction ? ` previousAction=${previousAction}` : ""} taskId=${taskId} messageId=${messageId}`
   );
   await updateStatus2(cfg2, messageId, "TYPING");
   syncLocalTaskStatus(workdir, taskId, msg2, "TYPING");
@@ -5031,7 +5194,7 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
       eventSession.addCliStep("\u51C6\u5907\u7279\u6027\u5206\u652F", "\u5DF2\u7F13\u5B58\uFF0C\u8DF3\u8FC7", "skip");
       await syncPrepLog();
     }
-    if (shouldEnsureWebIdePullRequests(msg2.action)) {
+    if (shouldEnsureWebIdePullRequests(effectiveAction)) {
       if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
       await runPrepStep(
         "\u9A8C\u6536\u524D\u63A8\u9001",
@@ -5137,8 +5300,8 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
       "running"
     );
     await syncPrepLog();
-    const startLocalServices = isStartLocalServicesAction(msg2.action);
-    const designAction = isDesignAction(msg2.action);
+    const startLocalServices = isStartLocalServicesAction(effectiveAction);
+    const designAction = isDesignAction(effectiveAction);
     const useNewAgent = msg2.useNewAgent === true;
     const toolNames = Array.isArray(msg2.tools) ? msg2.tools.map((t) => String(t).trim()).filter(Boolean) : [];
     if (useNewAgent && !startLocalServices) {
@@ -5149,7 +5312,7 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
       }
     }
     const savedAgentId = startLocalServices || useNewAgent ? void 0 : designAction ? loadWebIdeDesignAgentId(workdir, taskId) : loadWebIdeAgentId(workdir, taskId);
-    const promptPayload = toolNames.includes("MysqlExecute") ? parseWebIdePromptPayload(msg2.content) : null;
+    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) {
       console.warn(
@@ -5239,6 +5402,15 @@ ${assumptionAnswersText}` : msg2.content,
               eventSession.getCliSteps()
             );
             await webIdeRunAction(cfg2, taskId, startAction, { runId });
+          } else if (msg2.action === "continue") {
+            try {
+              await webIdeAttachContinueRun(cfg2, taskId, runId);
+            } catch (err) {
+              console.warn(
+                "[apm] attach continue run failed:",
+                err instanceof Error ? err.message : err
+              );
+            }
           }
         }
       }
@@ -5265,7 +5437,7 @@ ${assumptionAnswersText}` : msg2.content,
         detail,
         tokenUsage
       );
-      if (sqlExecutionId && msg2.action !== "request-bugfix") {
+      if (sqlExecutionId && effectiveAction !== "request-bugfix") {
         try {
           await api.cli.webideFinalizeSqlExecution({
             executionId: sqlExecutionId,
@@ -5290,7 +5462,7 @@ ${assumptionAnswersText}` : msg2.content,
         "\u5DF2\u53D6\u6D88",
         tokenUsage
       );
-      if (sqlExecutionId && msg2.action !== "request-bugfix") {
+      if (sqlExecutionId && effectiveAction !== "request-bugfix") {
         try {
           await api.cli.webideFinalizeSqlExecution({
             executionId: sqlExecutionId,
@@ -5317,7 +5489,7 @@ ${assumptionAnswersText}` : msg2.content,
       id: messageId,
       content: fallback
     });
-    if ((msg2.action === "write-plan" || msg2.action === "revise-plan") && outcome.createPlan && outcome.createPlan.trim()) {
+    if ((effectiveAction === "write-plan" || effectiveAction === "revise-plan" || effectiveAction === "request-write-plan" || effectiveAction === "request-revise-plan" || effectiveAction === "start-write-plan") && outcome.createPlan && outcome.createPlan.trim()) {
       try {
         await api.cli.webideUpsertPlan({
           taskId,
@@ -5325,12 +5497,12 @@ ${assumptionAnswersText}` : msg2.content,
         });
       } catch (err) {
         console.warn(
-          `[apm] ${msg2.action} \u8865\u5199\u8BA1\u5212\u5931\u8D25:`,
+          `[apm] ${effectiveAction} \u8865\u5199\u8BA1\u5212\u5931\u8D25:`,
           err instanceof Error ? err.message : err
         );
       }
     }
-    if (isDesignAction(msg2.action)) {
+    if (isDesignAction(effectiveAction)) {
       if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
       try {
         const uploaded = await uploadWebIdeDesignArtifacts(
@@ -5339,7 +5511,7 @@ ${assumptionAnswersText}` : msg2.content,
           workdir
         );
         console.log(
-          `[apm] webide \u8BBE\u8BA1\u4EA7\u7269\u4E0A\u4F20 action=${msg2.action} uploaded=${uploaded.uploaded} skipped=${uploaded.skipped} files=${uploaded.artifacts.map((a) => a.name).join(",")}`
+          `[apm] webide \u8BBE\u8BA1\u4EA7\u7269\u4E0A\u4F20 action=${effectiveAction} uploaded=${uploaded.uploaded} skipped=${uploaded.skipped} files=${uploaded.artifacts.map((a) => a.name).join(",")}`
         );
       } catch (err) {
         const detail = err instanceof Error ? err.message : String(err);
@@ -5354,27 +5526,27 @@ ${assumptionAnswersText}` : msg2.content,
         return;
       }
     }
-    if (shouldCommitAfterWebIdeMessage(msg2.action)) {
+    if (shouldCommitAfterWebIdeMessage(effectiveAction)) {
       if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
       const committed = await commitWorkspaceReposIfDirty(
         workdir,
-        `chore(webide): sync after ${msg2.action} (${taskId})`
+        `chore(webide): sync after ${effectiveAction} (${taskId})`
       );
       console.log(
-        `[apm] webide \u515C\u5E95 commit action=${msg2.action} repos=${committed}`
+        `[apm] webide \u515C\u5E95 commit action=${effectiveAction} repos=${committed}`
       );
       if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
       const pushed = await pushWorkspaceRepos(workdir);
       console.log(
-        `[apm] webide \u81EA\u52A8 push action=${msg2.action} repos=${pushed}`
+        `[apm] webide \u81EA\u52A8 push action=${effectiveAction} repos=${pushed}`
       );
     }
-    if (shouldEnsureWebIdePullRequestsAfterAgent(msg2.action)) {
+    if (shouldEnsureWebIdePullRequestsAfterAgent(effectiveAction)) {
       if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
-      if (!shouldCommitAfterWebIdeMessage(msg2.action)) {
+      if (!shouldCommitAfterWebIdeMessage(effectiveAction)) {
         const pushed = await pushWorkspaceRepos(workdir);
         console.log(
-          `[apm] webide create-pr \u524D push action=${msg2.action} repos=${pushed}`
+          `[apm] webide create-pr \u524D push action=${effectiveAction} repos=${pushed}`
         );
       }
       const prResult = await ensureWebIdePullRequests(cfg2, taskId, workdir);
@@ -5428,20 +5600,20 @@ ${assumptionAnswersText}` : msg2.content,
       null,
       tokenUsage
     );
-    const completeAction = completeActionForInbound(msg2.action);
+    const completeAction = completeActionForInbound(effectiveAction);
     if (completeAction && !pausedForAssumptions) {
       await webIdeRunAction(cfg2, taskId, completeAction);
     } else if (pausedForAssumptions) {
       console.log(
-        `[apm] \u672C\u8F6E\u505C\u5728\u5F85\u786E\u8BA4\u5047\u8BBE\uFF0C\u8DF3\u8FC7 complete action=${msg2.action} taskId=${taskId}`
+        `[apm] \u672C\u8F6E\u505C\u5728\u5F85\u786E\u8BA4\u5047\u8BBE\uFF0C\u8DF3\u8FC7 complete action=${effectiveAction} taskId=${taskId}`
       );
     }
     await updateStatus2(cfg2, messageId, "SUCCESS");
     syncLocalTaskStatus(workdir, taskId, msg2, "SUCCESS");
     console.log(
-      `[apm] webide-message \u5B8C\u6210 action=${msg2.action} messageId=${messageId} agentId=${outcome.agentId}`
+      `[apm] webide-message \u5B8C\u6210 action=${msg2.action}${previousAction ? ` previousAction=${previousAction}` : ""} messageId=${messageId} agentId=${outcome.agentId}`
     );
-    if (msg2.action === "request-accept") {
+    if (effectiveAction === "request-accept" || effectiveAction === "start-accept") {
       try {
         await cleanWebIdeWorkspaceCache(taskId, workdir, cfg2);
       } catch (err) {
@@ -5468,7 +5640,7 @@ ${assumptionAnswersText}` : msg2.content,
         statusErr instanceof Error ? statusErr.message : statusErr
       );
     }
-    const completeAction = completeActionForInbound(msg2.action);
+    const completeAction = completeActionForInbound(effectiveAction);
     if (completeAction === "complete-assessment" && !pausedForAssumptions) {
       try {
         await webIdeRunAction(cfg2, taskId, completeAction, { force: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-project-manage-cli",
-  "version": "8.1.12",
+  "version": "8.1.14",
   "description": "命令行工具：后续用于调用平台后端 API 完成运维与自动化操作",
   "type": "module",
   "private": false,