ai-project-manage-cli 8.1.14 → 8.1.16

package/dist/index.js

@@ -279,22 +279,6 @@ var requestConfig = {
     cursorStoreDeleteRunEvents: defineEndpoint({
       method: "POST",
       path: "/cli/cursor-store/run-events/delete"
-    }),
-    cursorStorePutCheckpoint: defineEndpoint({
-      method: "PUT",
-      path: "/cli/cursor-store/checkpoints"
-    }),
-    cursorStoreGetCheckpoint: defineEndpoint({
-      method: "GET",
-      path: "/cli/cursor-store/checkpoints/get"
-    }),
-    cursorStoreListCheckpoints: defineEndpoint({
-      method: "POST",
-      path: "/cli/cursor-store/checkpoints/list"
-    }),
-    cursorStoreDeleteCheckpoints: defineEndpoint({
-      method: "POST",
-      path: "/cli/cursor-store/checkpoints/delete"
     })
   }
 };

package/dist/worker-script.js

@@ -190,22 +190,6 @@ var requestConfig = {
     cursorStoreDeleteRunEvents: defineEndpoint({
       method: "POST",
       path: "/cli/cursor-store/run-events/delete"
-    }),
-    cursorStorePutCheckpoint: defineEndpoint({
-      method: "PUT",
-      path: "/cli/cursor-store/checkpoints"
-    }),
-    cursorStoreGetCheckpoint: defineEndpoint({
-      method: "GET",
-      path: "/cli/cursor-store/checkpoints/get"
-    }),
-    cursorStoreListCheckpoints: defineEndpoint({
-      method: "POST",
-      path: "/cli/cursor-store/checkpoints/list"
-    }),
-    cursorStoreDeleteCheckpoints: defineEndpoint({
-      method: "POST",
-      path: "/cli/cursor-store/checkpoints/delete"
     })
   }
 };
@@ -2472,77 +2456,11 @@ function createPtySessionMcpServers(cfg2) {
   };
 }
 
+// src/commands/connect/local-sqlite-agent-store.ts
+import { composeLocalAgentStore } from "@cursor/sdk";
+import { SqliteLocalAgentStore } from "@cursor/sdk/sqlite";
+
 // src/commands/connect/remote-local-agent-store.ts
-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;
@@ -2597,51 +2515,32 @@ function fromApiRun(row) {
     latestCheckpointRef: asCheckpointRef(row.latestCheckpointRef) ?? null
   };
 }
-function fromApiEvent(row) {
-  return {
-    runId: row.runId,
-    seq: row.seq,
-    offset: row.offset,
-    eventType: row.eventType,
-    payload: row.payload,
-    payloadRef: row.payloadRef,
-    idempotencyKey: row.idempotencyKey,
-    createdAt: row.createdAt
-  };
-}
-function bytesToBase64(data) {
-  return Buffer.from(data).toString("base64");
-}
-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 }) => ({
-        client,
-        bucket
-      }));
-    }
-    return minioCache;
-  }
-  function rememberCheckpoint(agentId, blobId, data) {
-    memoryCheckpointCache.set(checkpointCacheKey(agentId, blobId), data);
-    writeLocalCheckpoint(agentId, blobId, data);
+var unsupportedCheckpoints = {
+  async get() {
+    return null;
+  },
+  async create() {
+  },
+  async update() {
+  },
+  async delete() {
+  },
+  async list() {
+    return { items: [] };
   }
-  function forgetCheckpoint(agentId, blobId) {
-    memoryCheckpointCache.delete(checkpointCacheKey(agentId, blobId));
-    deleteLocalCheckpoint(agentId, blobId);
+};
+var unsupportedRunEvents = {
+  async append() {
+    throw new Error("runEvents \u4EC5\u5B58\u672C\u673A SQLite");
+  },
+  async list() {
+    return { items: [] };
+  },
+  async delete() {
   }
+};
+function createRemoteLocalAgentStore(cfg2) {
+  const api = createApmApiClient(cfg2);
   async function upsertAgent(agent) {
     const row = await api.cli.cursorStoreUpsertAgent({
       agentId: agent.agentId,
@@ -2677,82 +2576,6 @@ function createRemoteLocalAgentStore(cfg2) {
     });
     return fromApiRun(row);
   }
-  async function uploadCheckpointRemote(input) {
-    const createdAt = Date.now();
-    if (input.data.byteLength > INLINE_CHECKPOINT_MAX_BYTES) {
-      const { client, bucket } = await getMinio();
-      const objectKey = checkpointObjectKey(input.agentId, input.blobId);
-      await client.putObject(bucket, objectKey, Buffer.from(input.data), {
-        "Content-Type": "application/octet-stream"
-      });
-      await api.cli.cursorStorePutCheckpoint({
-        agentId: input.agentId,
-        blobId: input.blobId,
-        objectKey,
-        byteSize: input.data.byteLength,
-        createdAt
-      });
-      return;
-    }
-    await api.cli.cursorStorePutCheckpoint({
-      agentId: input.agentId,
-      blobId: input.blobId,
-      dataBase64: bytesToBase64(input.data),
-      byteSize: input.data.byteLength,
-      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) {
-      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);
-    }
-    rememberCheckpoint(input.agentId, input.blobId, bytes);
-    return bytes;
-  }
   return {
     agents: {
       async get(input) {
@@ -2807,10 +2630,11 @@ function createRemoteLocalAgentStore(cfg2) {
     },
     runs: {
       async get(input) {
-        const row = await api.cli.cursorStoreGetRun({
-          agentId: input.agentId,
-          runId: input.runId
+        const page = await api.cli.cursorStoreListRuns({
+          runIds: [input.runId],
+          limit: 1
         });
+        const row = page.items[0];
         return row ? fromApiRun(row) : null;
       },
       async create(input) {
@@ -2854,124 +2678,54 @@ function createRemoteLocalAgentStore(cfg2) {
         return result;
       }
     },
-    runEvents: {
-      async append(input) {
-        const { items } = await api.cli.cursorStoreAppendRunEvents({
-          events: [
-            {
-              runId: input.runId,
-              eventType: input.eventType,
-              payload: input.payload,
-              payloadRef: input.payloadRef ?? null,
-              idempotencyKey: input.idempotencyKey ?? null
-            }
-          ]
-        });
-        const row = items[0];
-        if (!row) {
-          throw new Error("cursor-store append run event \u672A\u8FD4\u56DE\u7ED3\u679C");
-        }
-        return fromApiEvent(row);
-      },
-      async list(input) {
-        const page = await api.cli.cursorStoreListRunEvents({
-          runId: input.runId,
-          afterOffset: input.afterOffset ?? null,
-          limit: input.limit
-        });
-        return {
-          items: page.items.map(fromApiEvent),
-          ...page.nextOffset ? { nextOffset: page.nextOffset } : {}
-        };
-      },
-      async delete(input) {
-        const runIds = input.filter.runIds?.map((id) => id.trim()).filter(Boolean);
-        if (runIds && runIds.length > 0) {
-          await api.cli.cursorStoreDeleteRunEvents({ runIds });
-          return;
-        }
-        let cursor;
-        for (; ; ) {
-          const page = await api.cli.cursorStoreListRuns({
-            cursor,
-            limit: 200
-          });
-          if (page.items.length === 0) break;
-          await api.cli.cursorStoreDeleteRunEvents({
-            runIds: page.items.map((item) => item.runId)
-          });
-          if (!page.nextCursor) break;
-          cursor = page.nextCursor;
-        }
-      }
-    },
-    checkpoints: {
-      async get(input) {
-        return readCheckpointBytes(input);
-      },
-      async create(input) {
-        await putCheckpoint(input);
-      },
-      async update(input) {
-        await putCheckpoint(input);
-      },
-      async delete(input) {
-        const agentIds = input.filter.agentIds?.map((id) => id.trim()).filter(Boolean);
-        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;
-        for (; ; ) {
-          const page = await api.cli.cursorStoreListCheckpoints({
-            cursor,
-            limit: 200
-          });
-          if (page.items.length === 0) break;
-          await api.cli.cursorStoreDeleteCheckpoints({
-            agentIds: [...new Set(page.items.map((item) => item.agentId))],
-            blobIds: page.items.map((item) => item.blobId)
-          });
-          if (!page.nextCursor) break;
-          cursor = page.nextCursor;
-        }
-        clearLocalCheckpointCache();
-        memoryCheckpointCache.clear();
-      },
-      async list(input) {
-        const page = await api.cli.cursorStoreListCheckpoints({
-          agentIds: input?.filter?.agentIds ? [...input.filter.agentIds] : void 0,
-          blobIds: input?.filter?.blobIds ? [...input.filter.blobIds] : void 0,
-          cursor: input?.filter?.cursor,
-          limit: input?.filter?.limit
-        });
-        return {
-          items: page.items.map((item) => item.blobId),
-          ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
-        };
-      }
-    }
+    checkpoints: unsupportedCheckpoints,
+    runEvents: unsupportedRunEvents
   };
 }
 
+// src/commands/connect/local-sqlite-agent-store.ts
+var sqliteByKey = /* @__PURE__ */ new Map();
+async function openSqliteLocalAgentStore(workspaceRef) {
+  const cwd = workspaceRef.trim();
+  if (!cwd) throw new Error("openSqliteLocalAgentStore: workspaceRef \u4E0D\u80FD\u4E3A\u7A7A");
+  const existing = sqliteByKey.get(cwd);
+  if (existing) return existing;
+  const pending2 = SqliteLocalAgentStore.open({ workspaceRef: cwd }).then(
+    (store) => {
+      console.log(
+        `[apm] Cursor store sqlite ready cwd=${cwd} stateRoot=${store.stateRoot}`
+      );
+      return store;
+    }
+  );
+  sqliteByKey.set(cwd, pending2);
+  return pending2;
+}
+async function createApmCursorAgentStore(cfg2, workspaceRef) {
+  const cwd = workspaceRef.trim();
+  const [sqlite, remote] = await Promise.all([
+    openSqliteLocalAgentStore(cwd),
+    Promise.resolve(createRemoteLocalAgentStore(cfg2))
+  ]);
+  return composeLocalAgentStore({
+    agents: remote.agents,
+    runs: remote.runs,
+    checkpoints: sqlite.checkpoints,
+    runEvents: sqlite.runEvents
+  });
+}
+async function purgeLocalSqliteAgentData(input) {
+  const agentId = input.agentId.trim();
+  const workspaceRef = input.workspaceRef.trim();
+  if (!agentId || !workspaceRef) return;
+  const sqlite = await openSqliteLocalAgentStore(workspaceRef);
+  const runIds = [...input.runIds ?? []];
+  if (runIds.length > 0) {
+    await sqlite.runEvents.delete({ filter: { runIds } });
+  }
+  await sqlite.checkpoints.delete({ filter: { agentIds: [agentId] } });
+}
+
 // src/commands/connect/core/worker/run-steer.ts
 var impl = null;
 var pending = null;
@@ -3017,7 +2771,7 @@ function formatCursorRunFailure(runId, options) {
   return `Cursor run \u5931\u8D25: ${runId} \u2014 ${details.join("\uFF1B")}`;
 }
 async function obtainAgent(ctx) {
-  const store = createRemoteLocalAgentStore(ctx.cfg);
+  const store = await createApmCursorAgentStore(ctx.cfg, ctx.cwd);
   const agentOptions = {
     apiKey: ctx.apiKey,
     model: { id: ctx.model || "default" },
@@ -3369,14 +3123,14 @@ function createThrottledWebIdeMessageLogSync(cfg2, ctx, onError, options) {
 
 // src/commands/sync-webide-agent.ts
 import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync5,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync5,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync4
+  readFileSync as readFileSync4,
+  unlinkSync,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 var REVISION_FILE = ".webide-agent.json";
 var RULE_KEY = /^[a-z0-9_]+$/;
 function withTrailingNewline(text) {
@@ -3384,10 +3138,10 @@ function withTrailingNewline(text) {
 `;
 }
 function readRevision(apmDir) {
-  const path3 = toFsPath(join5(apmDir, REVISION_FILE));
-  if (!existsSync6(path3)) return null;
+  const path3 = toFsPath(join4(apmDir, REVISION_FILE));
+  if (!existsSync5(path3)) return null;
   try {
-    const parsed = JSON.parse(readFileSync5(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path3, "utf8"));
     if (parsed?.version === 1 && parsed.revision?.trim()) {
       return parsed.revision.trim();
     }
@@ -3397,8 +3151,8 @@ function readRevision(apmDir) {
   return null;
 }
 function writeRevision(apmDir, revision) {
-  writeFileSync4(
-    toFsPath(join5(apmDir, REVISION_FILE)),
+  writeFileSync3(
+    toFsPath(join4(apmDir, REVISION_FILE)),
     `${JSON.stringify({ version: 1, revision }, null, 2)}
 `,
     "utf8"
@@ -3412,14 +3166,14 @@ async function syncWebIdeAgentFiles(workdir, cfg2) {
     throw new Error("[apm] \u5E73\u53F0\u672A\u8FD4\u56DE WebIDE \u89C4\u5219\u7248\u672C");
   }
   const apmDir = workspaceApmDir(workdir);
-  mkdirSync5(toFsPath(apmDir), { recursive: true });
+  mkdirSync4(toFsPath(apmDir), { recursive: true });
   if (readRevision(apmDir) === revision) {
     return { revision, wrote: false, ruleCount: bundle.rules?.length ?? 0 };
   }
-  const rulesDir = join5(apmDir, "rules");
-  mkdirSync5(toFsPath(rulesDir), { recursive: true });
-  writeFileSync4(
-    toFsPath(join5(apmDir, "AGENTS.md")),
+  const rulesDir = join4(apmDir, "rules");
+  mkdirSync4(toFsPath(rulesDir), { recursive: true });
+  writeFileSync3(
+    toFsPath(join4(apmDir, "AGENTS.md")),
     withTrailingNewline(bundle.guide ?? ""),
     "utf8"
   );
@@ -3430,8 +3184,8 @@ async function syncWebIdeAgentFiles(workdir, cfg2) {
       throw new Error(`[apm] \u975E\u6CD5\u89C4\u5219\u540D: ${key || "(\u7A7A)"}`);
     }
     keep.add(`${key}.md`);
-    writeFileSync4(
-      toFsPath(join5(rulesDir, `${key}.md`)),
+    writeFileSync3(
+      toFsPath(join4(rulesDir, `${key}.md`)),
       withTrailingNewline(rule.body ?? ""),
       "utf8"
     );
@@ -3439,7 +3193,7 @@ async function syncWebIdeAgentFiles(workdir, cfg2) {
   for (const name of readdirSync3(toFsPath(rulesDir))) {
     if (!name.endsWith(".md")) continue;
     if (keep.has(name)) continue;
-    unlinkSync2(toFsPath(join5(rulesDir, name)));
+    unlinkSync(toFsPath(join4(rulesDir, name)));
   }
   writeRevision(apmDir, revision);
   return {
@@ -3464,14 +3218,14 @@ async function ensureWorkspaceInitialized(workdir) {
 
 // src/utils/project-documents.ts
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync6,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync5
+  readFileSync as readFileSync5,
+  rmSync,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { createHash as createHash3 } from "crypto";
-import { dirname as dirname3, join as join6, relative as relative4, sep } from "path";
+import { createHash as createHash2 } from "crypto";
+import { dirname as dirname2, join as join5, relative as relative4, sep } from "path";
 var MANIFEST_FILE = "manifest.json";
 function normalizeProjectIdForPath(projectId) {
   const id = projectId.trim();
@@ -3485,11 +3239,11 @@ function normalizeProjectIdForPath(projectId) {
 }
 function projectDocumentsDir(apmRoot, projectId) {
   const id = normalizeProjectIdForPath(projectId);
-  return join6(apmRoot ?? workspaceApmDir(), "project", id);
+  return join5(apmRoot ?? workspaceApmDir(), "project", id);
 }
 function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
-  return join6(
+  return join5(
     projectDocumentsDir(apmRoot, projectId),
     ...normalized.split("/")
   );
@@ -3506,19 +3260,19 @@ function normalizeLocalDocumentPath(path3) {
   return segments.join("/");
 }
 function hashLocalFileContent(content) {
-  return createHash3("sha256").update(content, "utf8").digest("hex");
+  return createHash2("sha256").update(content, "utf8").digest("hex");
 }
 function readLocalManifest(apmRoot, projectId) {
-  const manifestPath2 = join6(
+  const manifestPath2 = join5(
     projectDocumentsDir(apmRoot, projectId),
     MANIFEST_FILE
   );
-  if (!existsSync7(manifestPath2)) {
+  if (!existsSync6(manifestPath2)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync6(manifestPath2, "utf8")
+      readFileSync5(manifestPath2, "utf8")
     );
   } catch {
     return null;
@@ -3526,13 +3280,13 @@ function readLocalManifest(apmRoot, projectId) {
 }
 function listLocalDocumentPaths(apmRoot, projectId) {
   const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync7(root)) {
+  if (!existsSync6(root)) {
     return [];
   }
   const paths = [];
   const walk = (dir) => {
     for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-      const abs = join6(dir, entry.name);
+      const abs = join5(dir, entry.name);
       if (entry.isDirectory()) {
         walk(abs);
         continue;
@@ -3651,8 +3405,8 @@ ${diagnostic ?? ""}`);
       const absPath = toFsPath(
         projectDocumentLocalPath(targetApmDir, projectId, doc.path)
       );
-      await ensureDirExists(dirname3(absPath));
-      writeFileSync5(absPath, doc.content, "utf8");
+      await ensureDirExists(dirname2(absPath));
+      writeFileSync4(absPath, doc.content, "utf8");
       downloaded += 1;
     }
   }
@@ -3661,13 +3415,13 @@ ${diagnostic ?? ""}`);
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path3)
     );
-    if (existsSync7(absPath)) {
-      rmSync2(absPath, { force: true });
+    if (existsSync6(absPath)) {
+      rmSync(absPath, { force: true });
       deleted += 1;
     }
   }
-  writeFileSync5(
-    toFsPath(join6(docsDir, MANIFEST_FILE)),
+  writeFileSync4(
+    toFsPath(join5(docsDir, MANIFEST_FILE)),
     `${JSON.stringify(remoteManifest, null, 2)}
 `,
     "utf8"
@@ -3710,7 +3464,7 @@ async function syncProjectDocumentsPush(cfg2, workdirPath, apmRoot, options) {
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path3)
     );
-    const content = readFileSync6(absPath, "utf8");
+    const content = readFileSync5(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
     if (remoteHashByPath.get(path3) === contentHash) {
       continue;
@@ -4195,18 +3949,18 @@ async function handleStartProject(cfg2, msg2, signal) {
 }
 
 // src/commands/connect/webide-agent-registry.ts
-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";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname3, resolve as resolve6 } from "node:path";
 function registryPath(workdir, taskId, fileName = "cursor-agent.json") {
   return resolve6(workdir, ".apm", "webide", taskId, fileName);
 }
 var DESIGN_AGENT_FILE = "design-agent.json";
 function readRegistry(path3) {
-  if (!existsSync8(path3)) {
+  if (!existsSync7(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 = {};
@@ -4235,8 +3989,8 @@ function readRegistry(path3) {
   return {};
 }
 function writeRegistry(path3, registry) {
-  mkdirSync6(dirname4(path3), { recursive: true });
-  writeFileSync6(path3, `${JSON.stringify(registry, null, 2)}
+  mkdirSync5(dirname3(path3), { recursive: true });
+  writeFileSync5(path3, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function syncWebIdeTaskState(workdir, taskId, patch) {
@@ -4277,7 +4031,7 @@ function saveWebIdeAgentId(workdir, taskId, agentId) {
 }
 function clearWebIdeAgentId(workdir, taskId) {
   const path3 = registryPath(workdir, taskId);
-  if (!existsSync8(path3)) return;
+  if (!existsSync7(path3)) return;
   syncWebIdeTaskState(workdir, taskId, { agentId: "" });
 }
 function loadWebIdeDesignAgentId(workdir, taskId) {
@@ -4297,7 +4051,7 @@ function saveWebIdeDesignAgentId(workdir, taskId, agentId) {
 }
 function clearWebIdeDesignAgentId(workdir, taskId) {
   const path3 = registryPath(workdir, taskId, DESIGN_AGENT_FILE);
-  if (!existsSync8(path3)) return;
+  if (!existsSync7(path3)) return;
   const current = readRegistry(path3);
   const next = { ...current };
   delete next.agentId;
@@ -4309,12 +4063,11 @@ function clearWebIdeDesignAgentId(workdir, taskId) {
 }
 
 // src/commands/clean-webide-cache.ts
-import { existsSync as existsSync9, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync8, rmSync as rmSync2 } from "node:fs";
 import { resolve as resolve7 } from "node:path";
-async function purgeCursorAgentStoreForAgent(cfg2, agentId) {
+async function purgeCursorAgentStoreForAgent(cfg2, agentId, workspaceRef) {
   const trimmedAgentId = agentId.trim();
   if (!trimmedAgentId) return false;
-  await flushPendingCheckpointUploads();
   const store = createRemoteLocalAgentStore(cfg2);
   const runIds = [];
   let cursor;
@@ -4331,13 +4084,16 @@ async function purgeCursorAgentStoreForAgent(cfg2, agentId) {
     }
     cursor = page.nextCursor;
   } while (cursor);
-  if (runIds.length > 0) {
-    await store.runEvents.delete({ filter: { runIds } });
-  }
   await store.runs.delete({ filter: { agentIds: [trimmedAgentId] } });
-  await store.checkpoints.delete({ filter: { agentIds: [trimmedAgentId] } });
   await store.agents.delete({ filter: { agentIds: [trimmedAgentId] } });
-  clearLocalCheckpointCache(trimmedAgentId);
+  const workdir = workspaceRef?.trim();
+  if (workdir) {
+    await purgeLocalSqliteAgentData({
+      workspaceRef: workdir,
+      agentId: trimmedAgentId,
+      runIds
+    });
+  }
   return true;
 }
 async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
@@ -4349,7 +4105,11 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
   const agentId = loadWebIdeAgentId(trimmedWorkdir, trimmedTaskId);
   if (agentId) {
     try {
-      const purged = await purgeCursorAgentStoreForAgent(cfg2, agentId);
+      const purged = await purgeCursorAgentStoreForAgent(
+        cfg2,
+        agentId,
+        trimmedWorkdir
+      );
       if (purged) {
         console.log(
           `[apm] \u5DF2\u6E05\u7406 Cursor agent store agentId=${agentId} taskId=${trimmedTaskId}`
@@ -4367,8 +4127,8 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
     );
   }
   const dir = resolve7(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
-  if (existsSync9(dir)) {
-    rmSync3(dir, { recursive: true, force: true });
+  if (existsSync8(dir)) {
+    rmSync2(dir, { recursive: true, force: true });
     console.log(`[apm] \u5DF2\u6E05\u7406 WebIDE \u7F13\u5B58 ${dir}`);
   } else {
     console.log(`[apm] WebIDE \u7F13\u5B58\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7 ${dir}`);
@@ -4689,8 +4449,8 @@ async function ensureWebIdePullRequests(cfg2, taskId, workdir) {
 }
 
 // src/commands/sync-webide-attachments.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } 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(/\/+$/, "");
@@ -4706,13 +4466,13 @@ async function downloadAttachment(cfg2, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path3 = join7(dir, MANIFEST_FILE2);
-  if (!existsSync10(path3)) {
+  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;
@@ -4722,15 +4482,15 @@ function loadManifest(dir) {
   return { version: 1, attachments: {} };
 }
 function saveManifest(dir, manifest) {
-  writeFileSync7(
-    join7(dir, MANIFEST_FILE2),
+  writeFileSync6(
+    join6(dir, MANIFEST_FILE2),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
 function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync10(dest)) return false;
+  if (!entry || !existsSync9(dest)) return false;
   if (entry.name !== item.name) return false;
   const createdAt = item.createdAt ?? "";
   return entry.createdAt === createdAt;
@@ -4745,7 +4505,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
   const nextManifest = { version: 1, attachments: {} };
   const names = [];
   for (const item of attachments) {
-    const dest = join7(dir, item.name);
+    const dest = join6(dir, item.name);
     const entry = manifest.attachments[item.id];
     const createdAt = item.createdAt ?? "";
     names.push(item.name);
@@ -4755,7 +4515,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
       continue;
     }
     const buffer = await downloadAttachment(cfg2, item.id);
-    writeFileSync7(dest, buffer);
+    writeFileSync6(dest, buffer);
     nextManifest.attachments[item.id] = {
       name: item.name,
       createdAt
@@ -4776,9 +4536,9 @@ async function syncWebIdeAttachments(cfg2, taskId, workdir, attachments) {
 }
 
 // src/commands/sync-webide-design.ts
-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";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync5, writeFileSync as writeFileSync7 } from "fs";
+import { join as join7 } from "path";
 
 // src/opc-shared-types.ts
 function webIdeDesignObjectKey(taskId, fileName) {
@@ -4796,15 +4556,15 @@ function webIdeDesignArtifactContentType(name) {
 // src/commands/sync-webide-design.ts
 var MANIFEST_FILE3 = ".sync-manifest.json";
 function hashBuffer(buf) {
-  return createHash4("sha256").update(buf).digest("hex");
+  return createHash3("sha256").update(buf).digest("hex");
 }
 function loadManifest2(dir) {
-  const path3 = join8(dir, MANIFEST_FILE3);
-  if (!existsSync11(path3)) {
+  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;
     }
@@ -4813,8 +4573,8 @@ function loadManifest2(dir) {
   return { version: 1, files: {} };
 }
 function saveManifest2(dir, manifest) {
-  writeFileSync8(
-    join8(dir, MANIFEST_FILE3),
+  writeFileSync7(
+    join7(dir, MANIFEST_FILE3),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
@@ -4842,13 +4602,13 @@ async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
   for (const art of artifacts) {
     const name = art.name?.trim();
     if (!name || !isWebIdeDesignArtifactName(name)) continue;
-    const localPath = join8(dir, name);
+    const localPath = join7(dir, name);
     const entry = manifest.files[name];
-    if (entry?.contentHash === art.contentHash && existsSync11(localPath)) {
+    if (entry?.contentHash === art.contentHash && existsSync10(localPath)) {
       continue;
     }
     const buf = await downloadDesignFile(cfg2, taskId, name);
-    writeFileSync8(localPath, buf);
+    writeFileSync7(localPath, buf);
     manifest.files[name] = { contentHash: hashBuffer(buf) };
     synced.push(name);
   }
@@ -4857,13 +4617,13 @@ async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
 }
 function listLocalDesignArtifactFiles(taskId, workdir) {
   const dir = webideDesignDir(taskId, workdir);
-  if (!existsSync11(dir)) return [];
+  if (!existsSync10(dir)) return [];
   const out = [];
   for (const name of readdirSync5(dir)) {
     if (!isWebIdeDesignArtifactName(name)) continue;
-    const absPath = join8(dir, name);
+    const absPath = join7(dir, name);
     if (!statSync5(absPath).isFile()) continue;
-    const buf = readFileSync9(absPath);
+    const buf = readFileSync8(absPath);
     if (buf.length === 0) continue;
     out.push({ name, absPath, contentHash: hashBuffer(buf) });
   }

package/package.json

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