@ycodium-ai/agent-antigravity 0.2.3130 → 0.2.3168

package/dist/index.js

@@ -1626,9 +1626,6 @@ function registerAntigravityAuthCommands(ctx) {
 // src/antigravityInstance.ts
 import * as NodeCrypto6 from "node:crypto";
 
-// src/agentProcess.ts
-import { nodeStreamsFromHandle } from "@ycodium-ai/plugin-api/process-stdin";
-
 // ../../packages/ycodium-acp-executor/src/executor.ts
 import * as NodeCrypto from "node:crypto";
 
@@ -26478,7 +26475,10 @@ function createAcpConnection(options2) {
     }
     pending.delete(key);
     try {
-      options2.onResponse?.(waiter.method);
+      options2.onResponse?.(
+        waiter,
+        Object.hasOwn(message, "error") ? { error: message["error"] } : { result: message["result"] }
+      );
     } catch {
     }
     if (Object.hasOwn(message, "error")) {
@@ -26611,12 +26611,17 @@ function createAcpConnection(options2) {
   options2.readable.on("end", onEnd);
   options2.readable.on("error", onError);
   options2.writable.once("error", onWritableError);
-  const begin = (method, params) => {
+  const begin = (method, params, promptId) => {
     failIfClosed();
     const id = nextRequestId;
     nextRequestId += 1;
     const { promise: promise2, resolve: resolve6, reject } = Promise.withResolvers();
-    pending.set(String(id), { method, resolve: resolve6, reject });
+    pending.set(String(id), {
+      method,
+      ...promptId === void 0 ? {} : { promptId },
+      resolve: resolve6,
+      reject
+    });
     const message = params === void 0 ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params };
     const written = Promise.race([writeMessage(message), promise2]).then(
       () => void 0,
@@ -26686,12 +26691,14 @@ function createExecutorLifecycle({
   notifyPromptSettled,
   eventStream,
   onInputDead,
-  shared
+  shared,
+  promptResults
 }) {
   const cancel = async (turnId) => {
     failIfDisposed();
     const started = requireStarted();
     const targetTurnId = turnId ?? shared.activeTurnId;
+    promptResults.stop(targetTurnId);
     if (targetTurnId !== void 0) {
       interruptedTurnIds.add(targetTurnId);
     }
@@ -26702,6 +26709,9 @@ function createExecutorLifecycle({
       if (shared.sessionId) {
         await connection.notify("session/cancel", { sessionId: shared.sessionId });
       }
+      await promptResults.wait(targetTurnId);
+      if (targetTurnId !== void 0 && shared.activeTurnId !== targetTurnId && !interruptedTurnIds.has(targetTurnId))
+        return;
       const settled = await waitForPromptIdle(cancelGraceMs);
       if (!settled) {
         throw new AcpExecutorCancelTimeoutError();
@@ -26722,6 +26732,7 @@ function createExecutorLifecycle({
               payload: { state: "cancelled", stopReason: "cancelled" }
             });
             interruptedTurnIds.delete(targetTurnId);
+            promptResults.forget(targetTurnId);
           }
         }
       }
@@ -26796,33 +26807,39 @@ function createExecutorLifecycle({
       if (!shared.disposed) emitSessionState("ready");
     }
   };
-  const dispose = async () => {
-    if (shared.disposed) {
-      return;
-    }
+  let disposing;
+  const dispose = () => {
+    if (disposing) return disposing;
+    shared.disposing = true;
+    promptResults.stop();
     settleAllApprovals("cancel");
     settleAllUserInputs();
     abortPendingSettlement("executor disposed");
     notifyPromptSettled();
     shared.abortLocalPrompt?.();
-    emit({
-      type: "session.exited",
-      ...stamp(),
-      provider: options2.provider,
-      threadId: options2.threadId,
-      payload: { reason: "disposed" }
-    });
-    shared.disposed = true;
-    shared.generation += 1;
-    shared.status = "disposed";
-    eventStream.close();
-    options2.readable.off("end", onInputDead);
-    options2.readable.off("error", onInputDead);
-    options2.readable.pause();
-    if (!shared.connectionClosed) {
-      await connection.awaitInboundIdle().catch(() => void 0);
-      await connection.close().catch(() => void 0);
-    }
+    disposing = (async () => {
+      promptResults.finishUnreceived();
+      await promptResults.wait();
+      emit({
+        type: "session.exited",
+        ...stamp(),
+        provider: options2.provider,
+        threadId: options2.threadId,
+        payload: { reason: "disposed" }
+      });
+      shared.disposed = true;
+      shared.generation += 1;
+      shared.status = "disposed";
+      eventStream.close();
+      options2.readable.off("end", onInputDead);
+      options2.readable.off("error", onInputDead);
+      options2.readable.pause();
+      if (!shared.connectionClosed) {
+        await connection.awaitInboundIdle().catch(() => void 0);
+        await connection.close().catch(() => void 0);
+      }
+    })();
+    return disposing;
   };
   return { cancel, compact, dispose };
 }
@@ -26926,12 +26943,14 @@ function createExecutorPrompt({
   promptMutex,
   applyRequestedModel,
   notifyPromptSettled,
-  shared
+  shared,
+  promptResults
 }) {
   const settleTurn = (input2) => {
-    if (!isLive(input2.expectedGeneration)) {
+    if (!isLive(input2.expectedGeneration) || input2.record.finished) {
       return false;
     }
+    promptResults.complete(input2.record);
     if (!acpPromptSettlementBelongsToContext({
       liveAcpSessionId: shared.sessionId ?? "",
       expectedAcpSessionId: input2.expectedSessionId,
@@ -26948,6 +26967,7 @@ function createExecutorPrompt({
     if (shared.status !== "disposed") {
       shared.status = "ready";
     }
+    const interrupted = promptResults.hasInterrupted(input2.turnId);
     emit({
       type: "turn.completed",
       ...stamp(),
@@ -26955,30 +26975,44 @@ function createExecutorPrompt({
       threadId: options2.threadId,
       turnId: input2.turnId,
       payload: {
-        state: input2.state,
-        stopReason: input2.stopReason,
+        state: interrupted ? "cancelled" : input2.state,
+        stopReason: interrupted ? "cancelled" : input2.stopReason,
         ...input2.errorMessage === void 0 ? {} : { errorMessage: input2.errorMessage },
         ...input2.state === "failed" ? failureCategoryField(input2.failureCategory) : {}
       }
     });
     interruptedTurnIds.delete(input2.turnId);
+    promptResults.forget(input2.turnId);
     return true;
   };
-  const sendPromptRpc = async (sessionId, promptParts, onWritten) => {
+  const sendPromptRpc = async (sessionId, promptParts, onWritten, record2) => {
     const settlementHooks = hooks.promptSettlement;
     const promptKey = settlementHooks === void 0 ? void 0 : randomId();
-    const pending = connection.begin("session/prompt", {
-      sessionId,
-      prompt: promptParts,
-      ...settlementHooks !== void 0 && promptKey !== void 0 ? settlementHooks.requestFields(promptKey) : {}
-    });
+    const pending = connection.begin(
+      "session/prompt",
+      {
+        sessionId,
+        prompt: promptParts,
+        ...settlementHooks !== void 0 && promptKey !== void 0 ? settlementHooks.requestFields(promptKey) : {}
+      },
+      record2?.promptId
+    );
     void pending.written.then(onWritten, () => void 0);
     const promptRpc = pending.response;
     if (settlementHooks === void 0 || promptKey === void 0) {
       return await promptRpc;
     } else {
       const { promise: early, resolve: settleEarly } = Promise.withResolvers();
-      shared.pendingSettlement = { promptKey, sessionId, settle: settleEarly };
+      shared.pendingSettlement = {
+        promptKey,
+        sessionId,
+        settle: settleEarly,
+        ...record2 === void 0 ? {} : {
+          onResponse: (response) => promptResults.receive(record2.promptId, response),
+          onError: () => promptResults.reject(record2.promptId),
+          hasResult: () => record2.response !== void 0
+        }
+      };
       try {
         const outcome = await Promise.race([
           promptRpc.then((value) => {
@@ -26999,9 +27033,11 @@ function createExecutorPrompt({
   const prompt = async (input2) => {
     failIfDisposed();
     const started = requireStarted();
+    let record2;
     const settle2 = (rest) => settleTurn({
       expectedGeneration: started.generation,
       expectedSessionId: started.sessionId,
+      record: record2,
       ...rest
     });
     let turnId;
@@ -27014,6 +27050,17 @@ function createExecutorPrompt({
         randomId
       );
       shared.promptsInFlight += 1;
+      record2 = promptResults.add(
+        {
+          promptId: randomId(),
+          sessionId: started.sessionId,
+          generation: started.generation,
+          turnId
+        },
+        () => {
+          finishPrompt();
+        }
+      );
       shared.activeTurnId = turnId;
       shared.status = "running";
       if (shared.promptsInFlight === 1) {
@@ -27030,6 +27077,42 @@ function createExecutorPrompt({
       threadMutex.release();
     }
     const promptParts = input2.prompt ?? (input2.text !== void 0 ? [{ type: "text", text: input2.text }] : [{ type: "text", text: "" }]);
+    let contextWindow;
+    const finishPrompt = () => {
+      if (!isLive(started.generation) || record2.finished) throw new AcpExecutorDisposedError();
+      const response2 = record2.response;
+      if (record2.interrupted || response2 === void 0) {
+        settle2({ turnId, stopReason: "cancelled", state: "cancelled" });
+        return { threadId: options2.threadId, turnId, stopReason: "cancelled" };
+      }
+      const stopReason = hooks.completedStopReason?.(response2) ?? response2.stopReason;
+      if (contextWindow !== void 0) {
+        emit({
+          type: "thread.token-usage.updated",
+          ...stamp(),
+          provider: options2.provider,
+          threadId: options2.threadId,
+          turnId,
+          payload: {
+            usage: {
+              usedTokens: contextWindow.usedTokens,
+              ...contextWindow.maxTokens === void 0 ? {} : { maxTokens: contextWindow.maxTokens }
+            }
+          }
+        });
+      }
+      settle2({
+        turnId,
+        stopReason,
+        state: response2.stopReason === "cancelled" ? "cancelled" : "completed"
+      });
+      return {
+        threadId: options2.threadId,
+        turnId,
+        stopReason,
+        ...response2.usage !== void 0 && response2.usage !== null ? { usage: response2.usage } : {}
+      };
+    };
     await promptMutex.acquire();
     let response;
     try {
@@ -27044,6 +27127,7 @@ function createExecutorPrompt({
           expectedGeneration: started.generation
         });
       }
+      failIfDisposed();
       if (isStale()) {
         settle2({ turnId, stopReason: "cancelled", state: "cancelled" });
         return { threadId: options2.threadId, turnId, stopReason: "cancelled" };
@@ -27051,10 +27135,15 @@ function createExecutorPrompt({
       closeActiveAssistantSegment(turnId);
       let written = false;
       try {
-        response = await sendPromptRpc(started.sessionId, promptParts, () => {
-          written = true;
-          input2.onDispatched?.(turnId);
-        });
+        response = await sendPromptRpc(
+          started.sessionId,
+          promptParts,
+          () => {
+            written = true;
+            input2.onDispatched?.(turnId);
+          },
+          record2
+        );
       } catch (error62) {
         if (shared.disposed) {
           throw new AcpExecutorDisposedError();
@@ -27093,8 +27182,7 @@ function createExecutorPrompt({
     if (turnId === void 0) {
       throw new AcpExecutorError("internal", "ACP prompt settled without a turn id");
     }
-    const settledTurnId = turnId;
-    let contextWindow;
+    if (record2.finished) throw new AcpExecutorDisposedError();
     if (hooks.readContextWindow !== void 0) {
       try {
         contextWindow = await hooks.readContextWindow({
@@ -27105,43 +27193,6 @@ function createExecutorPrompt({
         contextWindow = void 0;
       }
     }
-    const finishPrompt = () => {
-      if (interruptedTurnIds.has(settledTurnId)) {
-        settle2({ turnId: settledTurnId, stopReason: "cancelled", state: "cancelled" });
-        return {
-          threadId: options2.threadId,
-          turnId: settledTurnId,
-          stopReason: "cancelled"
-        };
-      }
-      const stopReason = hooks.completedStopReason?.(response) ?? response.stopReason;
-      if (contextWindow !== void 0) {
-        emit({
-          type: "thread.token-usage.updated",
-          ...stamp(),
-          provider: options2.provider,
-          threadId: options2.threadId,
-          turnId: settledTurnId,
-          payload: {
-            usage: {
-              usedTokens: contextWindow.usedTokens,
-              ...contextWindow.maxTokens === void 0 ? {} : { maxTokens: contextWindow.maxTokens }
-            }
-          }
-        });
-      }
-      settle2({
-        turnId: settledTurnId,
-        stopReason,
-        state: response.stopReason === "cancelled" ? "cancelled" : "completed"
-      });
-      return {
-        threadId: options2.threadId,
-        turnId: settledTurnId,
-        stopReason,
-        ...response.usage !== void 0 && response.usage !== null ? { usage: response.usage } : {}
-      };
-    };
     if (threadMutex.tryAcquire()) {
       try {
         return finishPrompt();
@@ -27159,6 +27210,91 @@ function createExecutorPrompt({
   return { sendPromptRpc, prompt };
 }
 
+// ../../packages/ycodium-acp-executor/src/executor/prompt-results.ts
+function createPromptResults({
+  options: options2,
+  shared
+}) {
+  const prompts = /* @__PURE__ */ new Map();
+  const add = (identity, finish) => {
+    const { promise: done, resolve: resolve6 } = Promise.withResolvers();
+    const record2 = {
+      ...identity,
+      finish,
+      done,
+      resolve: resolve6,
+      rejected: false,
+      interrupted: false,
+      finished: false
+    };
+    prompts.set(record2.promptId, record2);
+    return record2;
+  };
+  const receive = (promptId, response) => {
+    const record2 = prompts.get(promptId);
+    if (!record2 || record2.finished || record2.rejected || record2.response !== void 0) return;
+    if (shared.disposed || shared.generation !== record2.generation || shared.sessionId !== record2.sessionId)
+      return;
+    record2.response = response;
+  };
+  const reject = (promptId) => {
+    const record2 = prompts.get(promptId);
+    if (record2 && record2.response === void 0) record2.rejected = true;
+  };
+  const stop = (turnId) => {
+    for (const record2 of prompts.values()) {
+      if (!record2.finished && (turnId === void 0 || record2.turnId === turnId) && record2.response === void 0) {
+        record2.interrupted = true;
+      }
+    }
+  };
+  const complete = (record2) => {
+    record2.finished = true;
+    record2.resolve();
+  };
+  const hasInterrupted = (turnId) => [...prompts.values()].some((record2) => record2.turnId === turnId && record2.interrupted);
+  const forget = (turnId) => {
+    for (const [id, record2] of prompts) {
+      if (record2.turnId === turnId) {
+        complete(record2);
+        prompts.delete(id);
+      }
+    }
+  };
+  const wait = async (turnId) => {
+    const claimed = [...prompts.values()].filter(
+      (record2) => !record2.finished && record2.response !== void 0 && (turnId === void 0 || record2.turnId === turnId)
+    );
+    if (claimed.length === 0) return;
+    let timer;
+    try {
+      const drained = await Promise.race([
+        Promise.all(claimed.map((record2) => record2.done)).then(() => true),
+        new Promise((resolve6) => {
+          timer = setTimeout(() => resolve6(false), options2.resultDrainTimeoutMs ?? 2e3);
+        })
+      ]);
+      if (drained) return;
+      options2.log?.warn?.("ACP result settlement timed out", { threadId: options2.threadId });
+      for (const record2 of claimed) if (!record2.finished) record2.finish();
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const finishUnreceived = () => {
+    const claimedTurns = new Set(
+      [...prompts.values()].filter((record2) => !record2.finished && record2.response !== void 0).map((record2) => record2.turnId)
+    );
+    for (const record2 of prompts.values()) {
+      if (!record2.finished && record2.response === void 0) {
+        if (claimedTurns.has(record2.turnId)) record2.finish();
+        else complete(record2);
+      }
+    }
+  };
+  return { add, receive, reject, stop, complete, hasInterrupted, forget, wait, finishUnreceived };
+}
+
 // ../../packages/ycodium-acp-executor/src/user-input-pending.ts
 var userInputAnswerOptionId = (question, answers) => {
   const answer = answers[question.id];
@@ -27465,7 +27601,7 @@ function createExecutorRuntime({
     turnId: () => shared.activeTurnId
   });
   const failIfDisposed = () => {
-    if (shared.disposed) {
+    if (shared.disposed || shared.disposing) {
       throw new AcpExecutorDisposedError();
     }
   };
@@ -28057,6 +28193,7 @@ function createExecutorSettlement({
   const abortPendingSettlement = (reason, failureCategory) => {
     const waiting = shared.pendingSettlement;
     if (waiting === void 0) return;
+    if (waiting.hasResult?.()) return;
     shared.pendingSettlement = void 0;
     waiting.settle({
       error: withFailureCategory(
@@ -28078,6 +28215,7 @@ function createExecutorSettlement({
     shared.pendingSettlement = void 0;
     rememberSettledPromptKey(waiting.promptKey);
     if (signal.outcome === "error") {
+      waiting.onError?.();
       waiting.settle({
         error: withFailureCategory(
           new AcpExecutorRequestError(
@@ -28088,8 +28226,10 @@ function createExecutorSettlement({
         )
       });
     } else {
+      const response = { stopReason: signal.stopReason ?? "end_turn" };
+      waiting.onResponse?.(response);
       waiting.settle({
-        response: { stopReason: signal.stopReason ?? "end_turn" }
+        response
       });
     }
     return true;
@@ -28419,6 +28559,7 @@ function createAcpExecutor(options2) {
   const shared = {
     generation: 0,
     disposed: false,
+    disposing: false,
     status: "idle",
     sessionId: void 0,
     modelSelectionState: {
@@ -28506,6 +28647,7 @@ function createAcpExecutor(options2) {
     shared
   });
   const { rememberSettledPromptKey, abortPendingSettlement, settleFromNotification } = createExecutorSettlement({ hooks, shared });
+  const promptResults = createPromptResults({ options: options2, shared });
   const connection = createAcpConnection({
     readable: options2.readable,
     writable: options2.writable,
@@ -28516,8 +28658,12 @@ function createAcpExecutor(options2) {
       });
     },
     // 窗口在应答帧到达的那一刻同步收掉：应答之后的通知是真输出，不能再丢。
-    onResponse: (method) => {
+    onResponse: ({ method, promptId }, outcome) => {
       if (method === "session/load") shared.sessionLoadInFlight = false;
+      if (promptId !== void 0) {
+        if ("result" in outcome) promptResults.receive(promptId, outcome.result);
+        else promptResults.reject(promptId);
+      }
     },
     onNotification: (notification) => {
       if (notification.method === "session/update") {
@@ -28582,6 +28728,7 @@ function createAcpExecutor(options2) {
     shared
   });
   const { sendPromptRpc, prompt } = createExecutorPrompt({
+    promptResults,
     isLive,
     closeActiveAssistantSegment,
     emit,
@@ -28601,6 +28748,7 @@ function createAcpExecutor(options2) {
     shared
   });
   const { cancel, compact, dispose } = createExecutorLifecycle({
+    promptResults,
     failIfDisposed,
     requireStarted,
     interruptedTurnIds,
@@ -28652,6 +28800,27 @@ function createAcpExecutor(options2) {
   };
 }
 
+// ../../packages/ycodium-acp-executor/src/session-registry.ts
+function createAcpSessionRegistry(threads, stopBooked) {
+  const requireThread = (threadId) => {
+    const booked = threads.get(threadId);
+    if (!booked) throw new Error(`unknown thread ${threadId}`);
+    if (booked.closing) throw new Error(`thread ${threadId} is closing`);
+    return booked;
+  };
+  const stopSession = (threadId, booked = threads.get(threadId)) => {
+    if (!booked) return Promise.resolve();
+    booked.closing ??= Promise.resolve().then(() => stopBooked(booked)).then(() => {
+      if (threads.get(threadId) === booked) threads.delete(threadId);
+    });
+    return booked.closing;
+  };
+  const stopAll = () => Promise.all([...threads].map(([threadId, booked]) => stopSession(threadId, booked))).then(
+    () => void 0
+  );
+  return { requireThread, stopSession, stopAll };
+}
+
 // ../../packages/ycodium-acp-executor/src/start-abort.ts
 function throwIfStartAborted(signal) {
   if (signal?.aborted) throw new Error("aborted");
@@ -28742,6 +28911,9 @@ function acpAgentVersion(initializeResult) {
 }
 var MAX_VERSION_OUTPUT_BYTES = 64 * 1024;
 
+// src/agentProcess.ts
+import { nodeStreamsFromHandle } from "@ycodium-ai/plugin-api/process-stdin";
+
 // src/clock.ts
 var realAgentClock = {
   now: () => Date.now(),
@@ -30073,7 +30245,7 @@ function createAntigravitySession({
   threads,
   mutable,
   resolveInput,
-  stopBooked,
+  stopSession,
   login,
   noteSession,
   recordCatalog,
@@ -30088,8 +30260,8 @@ function createAntigravitySession({
       if (cwd.trim() === "") throw new Error("workspace path missing");
       const existing = threads.get(input2.threadId);
       if (existing !== void 0) {
-        threads.delete(input2.threadId);
-        await stopBooked(existing);
+        await stopSession(input2.threadId, existing);
+        if (mutable.disposed) throw new Error("instance disposed");
         throwIfStartAborted(signal);
       }
       const lease = await deps.runtime.acquire(resolveInput);
@@ -30313,10 +30485,9 @@ import * as NodeCrypto4 from "node:crypto";
 function createAntigravityTurn({
   deps,
   events,
-  threads,
   mutable,
   requireThread,
-  stopBooked,
+  stopSession,
   login,
   pushTaskEvents
 }) {
@@ -30353,8 +30524,7 @@ function createAntigravityTurn({
       ...base,
       payload: { state: "completed", stopReason: "end_turn" }
     });
-    threads.delete(input2.threadId);
-    await stopBooked(booked);
+    await stopSession(input2.threadId, booked);
     return { threadId: input2.threadId, turnId };
   };
   return {
@@ -32162,6 +32332,7 @@ async function createAntigravityInstance(config2, host, deps) {
   const events = new EventBus();
   const threads = /* @__PURE__ */ new Map();
   const mutable = { disposed: false };
+  let disposeTask;
   const unregister = deps.runtime.registerInstance({
     instanceId: host.instanceId,
     host,
@@ -32174,11 +32345,6 @@ async function createAntigravityInstance(config2, host, deps) {
     processEnv
   };
   const resolveExecutable = () => deps.runtime.resolve(resolveInput);
-  const requireThread = (threadId) => {
-    const booked = threads.get(threadId);
-    if (!booked) throw new Error(`unknown thread ${threadId}`);
-    return booked;
-  };
   const stopBooked = async (booked) => {
     for (const stopped of booked.background.finish()) events.push(stopped);
     await booked.executor.dispose().catch(() => void 0);
@@ -32190,6 +32356,7 @@ async function createAntigravityInstance(config2, host, deps) {
       });
     }
   };
+  const { requireThread, stopSession, stopAll } = createAcpSessionRegistry(threads, stopBooked);
   const helpers = createAntigravityTextGeneration({
     host,
     profile: dirs.profile,
@@ -32205,8 +32372,10 @@ async function createAntigravityInstance(config2, host, deps) {
   });
   const stopAllSessions = async (keepThreadId) => {
     const targets = [...threads].filter(([threadId]) => threadId !== keepThreadId);
-    for (const [threadId] of targets) threads.delete(threadId);
-    await Promise.all([...targets.map(([, booked]) => stopBooked(booked)), helpers.stopRunning()]);
+    await Promise.all([
+      ...targets.map(([threadId, booked]) => stopSession(threadId, booked)),
+      helpers.stopRunning()
+    ]);
   };
   const login = createLoginController({
     host,
@@ -32304,7 +32473,7 @@ async function createAntigravityInstance(config2, host, deps) {
     threads,
     mutable,
     resolveInput,
-    stopBooked,
+    stopSession,
     login,
     noteSession,
     recordCatalog,
@@ -32314,10 +32483,9 @@ async function createAntigravityInstance(config2, host, deps) {
   const turn = createAntigravityTurn({
     deps,
     events,
-    threads,
     mutable,
     requireThread,
-    stopBooked,
+    stopSession,
     login,
     pushTaskEvents
   });
@@ -32364,11 +32532,10 @@ async function createAntigravityInstance(config2, host, deps) {
     sendTurn: turn.sendTurn,
     interruptTurn: async (threadId, turnId) => {
       const booked = threads.get(threadId);
-      if (booked === void 0) return;
+      if (booked === void 0 || booked.closing) return;
       host.log.info("interrupt turn", { threadId, turnId });
       if (booked.session.status !== "running" && booked.background.hasPromoted()) {
-        threads.delete(threadId);
-        await stopBooked(booked);
+        await stopSession(threadId, booked);
         return;
       }
       await booked.executor.cancel(turnId);
@@ -32400,12 +32567,7 @@ async function createAntigravityInstance(config2, host, deps) {
       };
       if (applied !== void 0) booked.appliedModeId = applied;
     },
-    stopSession: async (threadId) => {
-      const booked = threads.get(threadId);
-      if (booked === void 0) return;
-      threads.delete(threadId);
-      await stopBooked(booked);
-    },
+    stopSession: (threadId) => stopSession(threadId),
     readThread: async (threadId) => {
       const booked = requireThread(threadId);
       return { threadId, turns: booked.turns };
@@ -32413,17 +32575,18 @@ async function createAntigravityInstance(config2, host, deps) {
     events,
     textGeneration: helpers.textGeneration,
     continuationKey: dirs.continuationKey,
-    dispose: async () => {
-      if (mutable.disposed) return;
+    dispose: () => {
+      if (disposeTask) return disposeTask;
       mutable.disposed = true;
-      unregisterLogin();
-      unsubscribeRuntime();
-      await login.dispose();
-      unregister();
-      const booked = [...threads.values()];
-      threads.clear();
-      await Promise.all([...booked.map((entry) => stopBooked(entry)), helpers.stopRunning()]);
-      events.close();
+      disposeTask = (async () => {
+        unregisterLogin();
+        unsubscribeRuntime();
+        await login.dispose();
+        unregister();
+        await Promise.all([stopAll(), helpers.stopRunning()]);
+        events.close();
+      })();
+      return disposeTask;
     }
   };
   return instance;
@@ -33498,7 +33661,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-antigravity",
-  apiVersion: 14,
+  apiVersion: 16,
   executors,
   activate(ctx) {
     const runtime = createRuntimeManager({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-antigravity",
-  "version": "0.2.3130",
+  "version": "0.2.3168",
   "description": "Google Antigravity executor: runs the Antigravity agent over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -31,8 +31,8 @@
     "typescript": "~6.0.3",
     "vite-plus": "0.2.2",
     "yauzl": "^3.4.0",
-    "@ycodium-ai/plugin-api": "0.2.3130",
-    "ycodium-acp-executor": "0.2.3130",
+    "ycodium-acp-executor": "0.2.3168",
+    "@ycodium-ai/plugin-api": "0.2.3168",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {