ai-project-manage-cli 8.1.4 → 8.1.6

package/dist/index.js

@@ -287,6 +287,11 @@ var requestConfig = {
       method: "POST",
       path: "/cli/webide/actions"
     }),
+    /** CLI 准备步骤实时回写到「待→进行中」转移线 */
+    webideUpdateTransitionPrepEvents: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/transition-prep-events"
+    }),
     webideUpsertMessageLog: defineEndpoint({
       method: "PUT",
       path: "/cli/webide/message-logs"
@@ -376,6 +381,66 @@ var requestConfig = {
     projectPackageEnsureContent: defineEndpoint({
       method: "PUT",
       path: "/cli/project-packages/ensure-content"
+    }),
+    cursorStoreUpsertAgent: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-store/agents"
+    }),
+    cursorStoreGetAgent: defineEndpoint({
+      method: "GET",
+      path: "/cli/cursor-store/agents/get"
+    }),
+    cursorStoreListAgents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/agents/list"
+    }),
+    cursorStoreDeleteAgents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/agents/delete"
+    }),
+    cursorStoreUpsertRun: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-store/runs"
+    }),
+    cursorStoreGetRun: defineEndpoint({
+      method: "GET",
+      path: "/cli/cursor-store/runs/get"
+    }),
+    cursorStoreListRuns: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/runs/list"
+    }),
+    cursorStoreDeleteRuns: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/runs/delete"
+    }),
+    cursorStoreAppendRunEvents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/run-events/append"
+    }),
+    cursorStoreListRunEvents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/run-events/list"
+    }),
+    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

@@ -35,6 +35,11 @@ var requestConfig = {
       method: "POST",
       path: "/cli/webide/actions"
     }),
+    /** CLI 准备步骤实时回写到「待→进行中」转移线 */
+    webideUpdateTransitionPrepEvents: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/transition-prep-events"
+    }),
     webideUpsertMessageLog: defineEndpoint({
       method: "PUT",
       path: "/cli/webide/message-logs"
@@ -124,6 +129,66 @@ var requestConfig = {
     projectPackageEnsureContent: defineEndpoint({
       method: "PUT",
       path: "/cli/project-packages/ensure-content"
+    }),
+    cursorStoreUpsertAgent: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-store/agents"
+    }),
+    cursorStoreGetAgent: defineEndpoint({
+      method: "GET",
+      path: "/cli/cursor-store/agents/get"
+    }),
+    cursorStoreListAgents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/agents/list"
+    }),
+    cursorStoreDeleteAgents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/agents/delete"
+    }),
+    cursorStoreUpsertRun: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-store/runs"
+    }),
+    cursorStoreGetRun: defineEndpoint({
+      method: "GET",
+      path: "/cli/cursor-store/runs/get"
+    }),
+    cursorStoreListRuns: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/runs/list"
+    }),
+    cursorStoreDeleteRuns: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/runs/delete"
+    }),
+    cursorStoreAppendRunEvents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/run-events/append"
+    }),
+    cursorStoreListRunEvents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/run-events/list"
+    }),
+    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"
     })
   }
 };
@@ -1156,6 +1221,16 @@ var EventSession = class {
     });
     this.markDirty(this.events.length - 1);
   }
+  /** 导出当前 CLI 准备步骤快照（供 start-* 写入转移日志） */
+  getCliSteps() {
+    return this.events.filter((e) => e.type === "cli_step" && typeof e.step === "string").map((e) => ({
+      step: String(e.step),
+      status: typeof e.status === "string" ? e.status : "ok",
+      text: typeof e.text === "string" ? e.text : "",
+      ...typeof e.at === "string" ? { at: e.at } : {},
+      ...typeof e.durationMs === "number" && Number.isFinite(e.durationMs) ? { durationMs: e.durationMs } : {}
+    }));
+  }
   formatEvent(event) {
     switch (event.type) {
       case "assistant": {
@@ -2385,6 +2460,330 @@ function createPtySessionMcpServers(cfg2) {
   };
 }
 
+// src/commands/connect/remote-local-agent-store.ts
+function asCheckpointRef(value) {
+  if (value === void 0) return void 0;
+  if (value === null) return null;
+  if (!value || typeof value !== "object") return null;
+  const row = value;
+  if (typeof row.rootBlobId !== "string" || !row.rootBlobId.trim()) {
+    return null;
+  }
+  return {
+    schemaVersion: 1,
+    rootBlobId: row.rootBlobId
+  };
+}
+function toApiCheckpointRef(ref) {
+  if (ref === void 0) return void 0;
+  if (ref === null) return null;
+  return {
+    schemaVersion: ref.schemaVersion,
+    rootBlobId: ref.rootBlobId
+  };
+}
+function fromApiAgent(row) {
+  return {
+    agentId: row.agentId,
+    cwd: row.cwd,
+    status: row.status,
+    activeRunId: row.activeRunId,
+    name: row.name,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    latestCheckpoint: asCheckpointRef(row.latestCheckpoint) ?? null,
+    sdkMetadata: row.sdkMetadata ?? void 0
+  };
+}
+function fromApiRun(row) {
+  return {
+    runId: row.runId,
+    requestId: row.requestId,
+    agentId: row.agentId,
+    turnNumber: row.turnNumber,
+    status: row.status,
+    model: row.model ?? null,
+    result: row.result,
+    error: row.error,
+    usageRef: row.usageRef,
+    usage: row.usage ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    startedAt: row.startedAt,
+    endedAt: row.endedAt,
+    startCheckpointRef: asCheckpointRef(row.startCheckpointRef) ?? null,
+    latestCheckpointRef: asCheckpointRef(row.latestCheckpointRef) ?? null
+  };
+}
+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"));
+}
+function createRemoteLocalAgentStore(cfg2) {
+  const api = createApmApiClient(cfg2);
+  async function upsertAgent(agent) {
+    const row = await api.cli.cursorStoreUpsertAgent({
+      agentId: agent.agentId,
+      cwd: agent.cwd,
+      status: agent.status,
+      activeRunId: agent.activeRunId ?? null,
+      name: agent.name ?? null,
+      latestCheckpoint: toApiCheckpointRef(agent.latestCheckpoint) ?? null,
+      sdkMetadata: agent.sdkMetadata ?? null,
+      createdAt: agent.createdAt,
+      updatedAt: agent.updatedAt
+    });
+    return fromApiAgent(row);
+  }
+  async function upsertRun(run) {
+    const row = await api.cli.cursorStoreUpsertRun({
+      runId: run.runId,
+      agentId: run.agentId,
+      requestId: run.requestId ?? null,
+      turnNumber: run.turnNumber,
+      status: run.status,
+      model: run.model ?? null,
+      result: run.result ?? null,
+      error: run.error ?? null,
+      usageRef: run.usageRef ?? null,
+      usage: run.usage ?? null,
+      startCheckpointRef: toApiCheckpointRef(run.startCheckpointRef) ?? null,
+      latestCheckpointRef: toApiCheckpointRef(run.latestCheckpointRef) ?? null,
+      createdAt: run.createdAt,
+      updatedAt: run.updatedAt,
+      startedAt: run.startedAt ?? null,
+      endedAt: run.endedAt ?? null
+    });
+    return fromApiRun(row);
+  }
+  async function putCheckpoint(input) {
+    await api.cli.cursorStorePutCheckpoint({
+      agentId: input.agentId,
+      blobId: input.blobId,
+      dataBase64: bytesToBase64(input.data),
+      byteSize: input.data.byteLength,
+      createdAt: Date.now()
+    });
+  }
+  return {
+    agents: {
+      async get(input) {
+        const row = await api.cli.cursorStoreGetAgent({
+          agentId: input.agentId
+        });
+        return row ? fromApiAgent(row) : null;
+      },
+      async create(input) {
+        return upsertAgent(input.agent);
+      },
+      async update(input) {
+        return upsertAgent(input.agent);
+      },
+      async delete(input) {
+        const agentIds = input.filter.agentIds?.map((id) => id.trim()).filter(Boolean);
+        const cwd = input.filter.cwd?.trim();
+        if (agentIds && agentIds.length > 0) {
+          await api.cli.cursorStoreDeleteAgents({ agentIds, cwd });
+          return;
+        }
+        if (cwd) {
+          await api.cli.cursorStoreDeleteAgents({ cwd });
+          return;
+        }
+        let cursor;
+        for (; ; ) {
+          const page = await api.cli.cursorStoreListAgents({
+            cursor,
+            limit: 200
+          });
+          if (page.items.length === 0) break;
+          await api.cli.cursorStoreDeleteAgents({
+            agentIds: page.items.map((item) => item.agentId)
+          });
+          if (!page.nextCursor) break;
+          cursor = page.nextCursor;
+        }
+      },
+      async list(input) {
+        const page = await api.cli.cursorStoreListAgents({
+          cursor: input?.filter?.cursor,
+          limit: input?.filter?.limit,
+          cwd: input?.filter?.cwd
+        });
+        const result = {
+          items: page.items.map(fromApiAgent),
+          ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
+        };
+        return result;
+      }
+    },
+    runs: {
+      async get(input) {
+        const row = await api.cli.cursorStoreGetRun({
+          agentId: input.agentId,
+          runId: input.runId
+        });
+        return row ? fromApiRun(row) : null;
+      },
+      async create(input) {
+        return upsertRun(input.run);
+      },
+      async update(input) {
+        return upsertRun(input.run);
+      },
+      async delete(input) {
+        const agentIds = input.filter.agentIds?.map((id) => id.trim()).filter(Boolean);
+        const runIds = input.filter.runIds?.map((id) => id.trim()).filter(Boolean);
+        if (agentIds && agentIds.length > 0 || runIds && runIds.length > 0) {
+          await api.cli.cursorStoreDeleteRuns({ agentIds, runIds });
+          return;
+        }
+        let cursor;
+        for (; ; ) {
+          const page = await api.cli.cursorStoreListRuns({
+            cursor,
+            limit: 200
+          });
+          if (page.items.length === 0) break;
+          await api.cli.cursorStoreDeleteRuns({
+            runIds: page.items.map((item) => item.runId)
+          });
+          if (!page.nextCursor) break;
+          cursor = page.nextCursor;
+        }
+      },
+      async list(input) {
+        const page = await api.cli.cursorStoreListRuns({
+          agentIds: input?.filter?.agentIds ? [...input.filter.agentIds] : void 0,
+          runIds: input?.filter?.runIds ? [...input.filter.runIds] : void 0,
+          cursor: input?.filter?.cursor,
+          limit: input?.filter?.limit
+        });
+        const result = {
+          items: page.items.map(fromApiRun),
+          ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
+        };
+        return result;
+      }
+    },
+    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) {
+        const row = await api.cli.cursorStoreGetCheckpoint({
+          agentId: input.agentId,
+          blobId: input.blobId
+        });
+        if (!row?.dataBase64) return null;
+        return base64ToBytes(row.dataBase64);
+      },
+      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 });
+          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;
+        }
+      },
+      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 } : {}
+        };
+      }
+    }
+  };
+}
+
 // src/commands/connect/cursor-agent.ts
 var noopRemoteLogSync = {
   schedule(_session) {
@@ -2406,11 +2805,13 @@ function formatCursorRunFailure(runId, options) {
   return `Cursor run \u5931\u8D25: ${runId} \u2014 ${details.join("\uFF1B")}`;
 }
 async function obtainAgent(ctx) {
+  const store = createRemoteLocalAgentStore(ctx.cfg);
   const agentOptions = {
     apiKey: ctx.apiKey,
     model: { id: ctx.model || "default" },
     local: {
       cwd: ctx.cwd,
+      store,
       ...ctx.customTools ? { customTools: ctx.customTools } : {},
       ...ctx.enableSandbox ? {
         sandboxOptions: { enabled: true },
@@ -2481,6 +2882,7 @@ async function runCursorAgent(cfg2, ctx, options) {
     `[apm] Cursor Agent \u5F00\u59CB messageId=${ctx.messageId} cwd=${workdir} sandbox=${enableSandbox}`
   );
   const { agent, resumed } = await obtainAgent({
+    cfg: cfg2,
     apiKey,
     model: ctx.model,
     cwd: workdir,
@@ -3681,48 +4083,34 @@ function clearWebIdeDesignAgentId(workdir, taskId) {
 // src/commands/clean-webide-cache.ts
 import { existsSync as existsSync8, rmSync as rmSync2 } from "node:fs";
 import { resolve as resolve7 } from "node:path";
-import { getDefaultSdkStateRoot } from "@cursor/sdk";
-async function purgeCursorAgentStoreForAgent(workdir, agentId) {
+async function purgeCursorAgentStoreForAgent(cfg2, agentId) {
   const trimmedAgentId = agentId.trim();
-  const trimmedWorkdir = workdir.trim();
-  if (!trimmedAgentId || !trimmedWorkdir) return false;
-  const stateRoot = getDefaultSdkStateRoot(trimmedWorkdir);
-  if (!existsSync8(stateRoot)) return false;
-  const { SqliteLocalAgentStore } = await import(
-    /* @vite-ignore */
-    "@cursor/sdk/sqlite"
-  );
-  const store = await SqliteLocalAgentStore.open({
-    workspaceRef: trimmedWorkdir
-  });
-  try {
-    const runIds = [];
-    let cursor;
-    do {
-      const page = await store.runs.list({
-        filter: {
-          agentIds: [trimmedAgentId],
-          ...cursor ? { cursor } : {},
-          limit: 200
-        }
-      });
-      for (const run of page.items) {
-        runIds.push(run.runId);
+  if (!trimmedAgentId) return false;
+  const store = createRemoteLocalAgentStore(cfg2);
+  const runIds = [];
+  let cursor;
+  do {
+    const page = await store.runs.list({
+      filter: {
+        agentIds: [trimmedAgentId],
+        ...cursor ? { cursor } : {},
+        limit: 200
       }
-      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] } });
-  } finally {
-    await store.dispose();
-  }
+    });
+    for (const run of page.items) {
+      runIds.push(run.runId);
+    }
+    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] } });
   return true;
 }
-async function cleanWebIdeWorkspaceCache(taskId, workdir) {
+async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
   const trimmedTaskId = taskId.trim();
   const trimmedWorkdir = workdir.trim();
   if (!trimmedTaskId || !trimmedWorkdir) {
@@ -3731,10 +4119,7 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir) {
   const agentId = loadWebIdeAgentId(trimmedWorkdir, trimmedTaskId);
   if (agentId) {
     try {
-      const purged = await purgeCursorAgentStoreForAgent(
-        trimmedWorkdir,
-        agentId
-      );
+      const purged = await purgeCursorAgentStoreForAgent(cfg2, agentId);
       if (purged) {
         console.log(
           `[apm] \u5DF2\u6E05\u7406 Cursor agent store agentId=${agentId} taskId=${trimmedTaskId}`
@@ -3823,6 +4208,36 @@ 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 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) {
@@ -4435,11 +4850,22 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
       }
     )
   };
+  let pausedForAssumptions = false;
+  let startAction = null;
   const syncPrepLog = async () => {
     const sync = logSyncRef.current;
-    if (!sync) return;
-    sync.schedule(eventSession);
-    await sync.flush(eventSession);
+    if (sync) {
+      sync.schedule(eventSession);
+      await sync.flush(eventSession);
+    }
+    if (startAction) {
+      await webIdeSyncTransitionPrepEvents(
+        cfg2,
+        taskId,
+        startAction,
+        eventSession.getCliSteps()
+      );
+    }
   };
   const runPrepStep = async (step, work, formatOk) => {
     eventSession.addCliStep(step, "\u8FDB\u884C\u4E2D\u2026", "running");
@@ -4456,12 +4882,8 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
       throw err;
     }
   };
-  let pausedForAssumptions = false;
   try {
-    const startAction = startActionForInbound(msg2.action);
-    if (startAction) {
-      await webIdeRunAction(cfg2, taskId, startAction);
-    }
+    startAction = startActionForInbound(msg2.action);
     if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
     let assumptionAnswersText;
     if (msg2.action === "confirm-assumptions") {
@@ -4722,6 +5144,15 @@ ${assumptionAnswersText}` : msg2.content,
           logSyncRef.current?.schedule(eventSession);
           await logSyncRef.current?.markRun(runId, "running");
           await logSyncRef.current?.flush(eventSession);
+          if (startAction) {
+            await webIdeSyncTransitionPrepEvents(
+              cfg2,
+              taskId,
+              startAction,
+              eventSession.getCliSteps()
+            );
+            await webIdeRunAction(cfg2, taskId, startAction, { runId });
+          }
         }
       }
     );
@@ -4925,7 +5356,7 @@ ${assumptionAnswersText}` : msg2.content,
     );
     if (msg2.action === "request-accept") {
       try {
-        await cleanWebIdeWorkspaceCache(taskId, workdir);
+        await cleanWebIdeWorkspaceCache(taskId, workdir, cfg2);
       } catch (err) {
         console.warn(
           "[apm] \u5408\u5E76 PR \u540E\u6E05\u7406 WebIDE agent \u7F13\u5B58\u5931\u8D25:",
@@ -4936,6 +5367,9 @@ ${assumptionAnswersText}` : msg2.content,
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     console.error(`[apm] webide-message \u5931\u8D25: ${detail}`);
+    if (startAction) {
+      await webIdeDiscardTransitionPrepDraft(cfg2, taskId, startAction);
+    }
     if (detail.includes("\u590D\u7528 Agent") || detail.includes("resume")) {
       clearWebIdeAgentId(workdir, taskId);
     }
@@ -4948,14 +5382,9 @@ ${assumptionAnswersText}` : msg2.content,
       );
     }
     const completeAction = completeActionForInbound(msg2.action);
-    if (completeAction && !pausedForAssumptions) {
+    if (completeAction === "complete-assessment" && !pausedForAssumptions) {
       try {
-        await webIdeRunAction(
-          cfg2,
-          taskId,
-          completeAction,
-          completeAction === "complete-assessment" ? { force: true } : void 0
-        );
+        await webIdeRunAction(cfg2, taskId, completeAction, { force: true });
       } catch (completeErr) {
         console.warn(
           `[apm] \u5931\u8D25\u540E\u56DE\u5199 complete \u8DF3\u8FC7 action=${completeAction}:`,

package/package.json

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