@ycodium-ai/agent-kimi 0.2.3130 → 0.2.3168

package/dist/index.js

@@ -24945,7 +24945,10 @@ function createAcpConnection(options) {
     }
     pending.delete(key);
     try {
-      options.onResponse?.(waiter.method);
+      options.onResponse?.(
+        waiter,
+        Object.hasOwn(message, "error") ? { error: message["error"] } : { result: message["result"] }
+      );
     } catch {
     }
     if (Object.hasOwn(message, "error")) {
@@ -25078,12 +25081,17 @@ function createAcpConnection(options) {
   options.readable.on("end", onEnd);
   options.readable.on("error", onError);
   options.writable.once("error", onWritableError);
-  const begin = (method, params) => {
+  const begin = (method, params, promptId) => {
     failIfClosed();
     const id = nextRequestId;
     nextRequestId += 1;
     const { promise: promise2, resolve: resolve3, reject } = Promise.withResolvers();
-    pending.set(String(id), { method, resolve: resolve3, reject });
+    pending.set(String(id), {
+      method,
+      ...promptId === void 0 ? {} : { promptId },
+      resolve: resolve3,
+      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,
@@ -25153,12 +25161,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);
     }
@@ -25169,6 +25179,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();
@@ -25189,6 +25202,7 @@ function createExecutorLifecycle({
               payload: { state: "cancelled", stopReason: "cancelled" }
             });
             interruptedTurnIds.delete(targetTurnId);
+            promptResults.forget(targetTurnId);
           }
         }
       }
@@ -25263,33 +25277,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: options.provider,
-      threadId: options.threadId,
-      payload: { reason: "disposed" }
-    });
-    shared.disposed = true;
-    shared.generation += 1;
-    shared.status = "disposed";
-    eventStream.close();
-    options.readable.off("end", onInputDead);
-    options.readable.off("error", onInputDead);
-    options.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: options.provider,
+        threadId: options.threadId,
+        payload: { reason: "disposed" }
+      });
+      shared.disposed = true;
+      shared.generation += 1;
+      shared.status = "disposed";
+      eventStream.close();
+      options.readable.off("end", onInputDead);
+      options.readable.off("error", onInputDead);
+      options.readable.pause();
+      if (!shared.connectionClosed) {
+        await connection.awaitInboundIdle().catch(() => void 0);
+        await connection.close().catch(() => void 0);
+      }
+    })();
+    return disposing;
   };
   return { cancel, compact, dispose };
 }
@@ -25393,12 +25413,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,
@@ -25415,6 +25437,7 @@ function createExecutorPrompt({
     if (shared.status !== "disposed") {
       shared.status = "ready";
     }
+    const interrupted = promptResults.hasInterrupted(input2.turnId);
     emit({
       type: "turn.completed",
       ...stamp(),
@@ -25422,30 +25445,44 @@ function createExecutorPrompt({
       threadId: options.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) => {
@@ -25466,9 +25503,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;
@@ -25481,6 +25520,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) {
@@ -25497,6 +25547,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: options.threadId, turnId, stopReason: "cancelled" };
+      }
+      const stopReason = hooks.completedStopReason?.(response2) ?? response2.stopReason;
+      if (contextWindow !== void 0) {
+        emit({
+          type: "thread.token-usage.updated",
+          ...stamp(),
+          provider: options.provider,
+          threadId: options.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: options.threadId,
+        turnId,
+        stopReason,
+        ...response2.usage !== void 0 && response2.usage !== null ? { usage: response2.usage } : {}
+      };
+    };
     await promptMutex.acquire();
     let response;
     try {
@@ -25511,6 +25597,7 @@ function createExecutorPrompt({
           expectedGeneration: started.generation
         });
       }
+      failIfDisposed();
       if (isStale()) {
         settle2({ turnId, stopReason: "cancelled", state: "cancelled" });
         return { threadId: options.threadId, turnId, stopReason: "cancelled" };
@@ -25518,10 +25605,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();
@@ -25560,8 +25652,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({
@@ -25572,43 +25663,6 @@ function createExecutorPrompt({
         contextWindow = void 0;
       }
     }
-    const finishPrompt = () => {
-      if (interruptedTurnIds.has(settledTurnId)) {
-        settle2({ turnId: settledTurnId, stopReason: "cancelled", state: "cancelled" });
-        return {
-          threadId: options.threadId,
-          turnId: settledTurnId,
-          stopReason: "cancelled"
-        };
-      }
-      const stopReason = hooks.completedStopReason?.(response) ?? response.stopReason;
-      if (contextWindow !== void 0) {
-        emit({
-          type: "thread.token-usage.updated",
-          ...stamp(),
-          provider: options.provider,
-          threadId: options.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: options.threadId,
-        turnId: settledTurnId,
-        stopReason,
-        ...response.usage !== void 0 && response.usage !== null ? { usage: response.usage } : {}
-      };
-    };
     if (threadMutex.tryAcquire()) {
       try {
         return finishPrompt();
@@ -25626,6 +25680,91 @@ function createExecutorPrompt({
   return { sendPromptRpc, prompt };
 }
 
+// ../../packages/ycodium-acp-executor/src/executor/prompt-results.ts
+function createPromptResults({
+  options,
+  shared
+}) {
+  const prompts = /* @__PURE__ */ new Map();
+  const add = (identity, finish) => {
+    const { promise: done, resolve: resolve3 } = Promise.withResolvers();
+    const record2 = {
+      ...identity,
+      finish,
+      done,
+      resolve: resolve3,
+      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((resolve3) => {
+          timer = setTimeout(() => resolve3(false), options.resultDrainTimeoutMs ?? 2e3);
+        })
+      ]);
+      if (drained) return;
+      options.log?.warn?.("ACP result settlement timed out", { threadId: options.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];
@@ -25932,7 +26071,7 @@ function createExecutorRuntime({
     turnId: () => shared.activeTurnId
   });
   const failIfDisposed = () => {
-    if (shared.disposed) {
+    if (shared.disposed || shared.disposing) {
       throw new AcpExecutorDisposedError();
     }
   };
@@ -26457,6 +26596,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(
@@ -26478,6 +26618,7 @@ function createExecutorSettlement({
     shared.pendingSettlement = void 0;
     rememberSettledPromptKey(waiting.promptKey);
     if (signal.outcome === "error") {
+      waiting.onError?.();
       waiting.settle({
         error: withFailureCategory(
           new AcpExecutorRequestError(
@@ -26488,8 +26629,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;
@@ -26819,6 +26962,7 @@ function createAcpExecutor(options) {
   const shared = {
     generation: 0,
     disposed: false,
+    disposing: false,
     status: "idle",
     sessionId: void 0,
     modelSelectionState: {
@@ -26906,6 +27050,7 @@ function createAcpExecutor(options) {
     shared
   });
   const { rememberSettledPromptKey, abortPendingSettlement, settleFromNotification } = createExecutorSettlement({ hooks, shared });
+  const promptResults = createPromptResults({ options, shared });
   const connection = createAcpConnection({
     readable: options.readable,
     writable: options.writable,
@@ -26916,8 +27061,12 @@ function createAcpExecutor(options) {
       });
     },
     // 窗口在应答帧到达的那一刻同步收掉：应答之后的通知是真输出，不能再丢。
-    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") {
@@ -26982,6 +27131,7 @@ function createAcpExecutor(options) {
     shared
   });
   const { sendPromptRpc, prompt } = createExecutorPrompt({
+    promptResults,
     isLive,
     closeActiveAssistantSegment,
     emit,
@@ -27001,6 +27151,7 @@ function createAcpExecutor(options) {
     shared
   });
   const { cancel, compact, dispose } = createExecutorLifecycle({
+    promptResults,
     failIfDisposed,
     requireStarted,
     interruptedTurnIds,
@@ -27052,6 +27203,41 @@ function createAcpExecutor(options) {
   };
 }
 
+// ../../packages/ycodium-acp-executor/src/session-registry.ts
+function createAcpSessionRegistry(threads, stopBooked2) {
+  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(() => stopBooked2(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/sessionProcess.ts
+var fileName = (path) => path.slice(path.lastIndexOf("/") + 1);
+var withoutExe = (name) => name.replace(/\.exe$/, "");
+function acpNativeSessionProcessMatcher(program, args) {
+  return (argv, platform) => {
+    const normalize = (value) => platform === "win32" ? withoutExe(value.replaceAll("\\", "/").toLowerCase()) : value;
+    const expected = normalize(program);
+    const actual = normalize(argv[0] ?? "");
+    const sameProgram = expected.includes("/") ? actual === expected : fileName(actual) === fileName(expected);
+    const rest = argv.slice(1);
+    return sameProgram && rest.length === args.length && rest.every((arg, i) => arg === args[i]);
+  };
+}
+
 // ../../packages/ycodium-acp-executor/src/prompt-dispatch.ts
 var dispatchAcpPrompt = (executor, input2) => {
   const { promise: dispatched, resolve: resolve3 } = Promise.withResolvers();
@@ -27967,6 +28153,44 @@ async function probeKimi(input2) {
   }
 }
 
+// src/openCommands.ts
+var basename = (path) => path.split(/[\\/]/).at(-1)?.toLowerCase() ?? "";
+var gitBashPath = (path) => path.replace(/^([A-Za-z]):[\\/]?/, (_match, drive) => `/${drive.toLowerCase()}/`).replaceAll("\\", "/").replace(/\/+$/, "");
+function kimiCommandMatcher(input2) {
+  return (argv, platform) => {
+    if (platform !== "win32" || input2.cwd.includes("'")) return false;
+    return argv.length === 3 && basename(argv[0] ?? "") === "bash.exe" && argv[1] === "-c" && argv[2] === `cd '${gitBashPath(input2.cwd)}' && ${input2.command}`;
+  };
+}
+var commandOf = (call) => {
+  if (call.kind !== "execute") return void 0;
+  const rawInput = call.rawInput;
+  if (typeof rawInput !== "object" || rawInput === null) return void 0;
+  const input2 = rawInput;
+  if (input2["run_in_background"] === true) return void 0;
+  const command = input2["command"];
+  return typeof command === "string" && command.trim() !== "" ? command : void 0;
+};
+function kimiOpenCommands(session) {
+  const commands = session.openToolCalls.flatMap((call) => {
+    const command = commandOf(call);
+    if (command === void 0) return [];
+    return [
+      {
+        toolCallId: call.toolCallId,
+        startedAtMs: call.startedAtMs,
+        matches: kimiCommandMatcher({ command, cwd: session.cwd })
+      }
+    ];
+  });
+  if (commands.length === 0) return void 0;
+  return {
+    rootPid: session.rootPid,
+    sessionProcess: acpNativeSessionProcessMatcher(session.program, session.args),
+    commands
+  };
+}
+
 // src/runtimeModeApproval.ts
 function acpRuntimeModeAutoApproves(runtimeMode, toolKind) {
   switch (runtimeMode) {
@@ -28078,12 +28302,9 @@ var createKimiInstance = (config2, host) => {
   const events = new EventBus();
   const threads = /* @__PURE__ */ new Map();
   let disposed = false;
+  let disposeTask;
   const usageHome = kimiEffectiveHome(resolveHomePath(recipe), process.env[recipe.homeEnvVar]);
-  const requireThread = (threadId) => {
-    const booked = threads.get(threadId);
-    if (!booked) throw new Error(`unknown thread ${threadId}`);
-    return booked;
-  };
+  const { requireThread, stopSession, stopAll } = createAcpSessionRegistry(threads, stopBooked);
   const instance = {
     probe: async () => {
       if (recipe.binaryPath.length === 0) {
@@ -28158,15 +28379,18 @@ var createKimiInstance = (config2, host) => {
       if (cwd.trim() === "") throw new Error("workspace path missing");
       const existing = threads.get(input2.threadId);
       if (existing !== void 0) {
-        await stopBooked(existing);
-        threads.delete(input2.threadId);
+        await stopSession(input2.threadId, existing);
+        if (disposed) throw new Error("instance disposed");
         throwIfStartAborted(signal);
       }
       const env = buildSpawnEnv(recipe, recipe.homePath);
-      const handle = await host.process.spawn({
+      const spawned = {
         program: recipe.binaryPath,
         args: tokenizeLaunchArgs(recipe.launchArgs),
-        cwd,
+        cwd
+      };
+      const handle = await host.process.spawn({
+        ...spawned,
         owner: { bindingId: host.bindingId },
         ...Object.keys(env).length > 0 ? { env } : {}
       });
@@ -28252,7 +28476,8 @@ var createKimiInstance = (config2, host) => {
           turns: [],
           executor,
           handle,
-          forwarding
+          forwarding,
+          spawned
         });
         host.log.info("session started", {
           threadId: input2.threadId,
@@ -28293,11 +28518,20 @@ var createKimiInstance = (config2, host) => {
     },
     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 });
       await booked.executor.cancel(turnId);
       await yieldTick();
     },
+    openCommandProcesses: async (threadId) => {
+      const booked = threads.get(threadId);
+      if (booked === void 0) return void 0;
+      return kimiOpenCommands({
+        rootPid: booked.handle.pid,
+        ...booked.spawned,
+        openToolCalls: booked.executor.openToolCalls()
+      });
+    },
     respondToRequest: async (threadId, requestId, decision, reason) => {
       const booked = requireThread(threadId);
       await booked.executor.respondToRequest(
@@ -28334,12 +28568,7 @@ var createKimiInstance = (config2, host) => {
         updatedAt: nowIso()
       };
     },
-    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 };
@@ -28355,13 +28584,14 @@ var createKimiInstance = (config2, host) => {
       ...createKimiTokenReader({ homePath: usageHome })
     },
     continuationKey: kimiContinuationKey(recipe),
-    dispose: async () => {
-      if (disposed) return;
+    dispose: () => {
+      if (disposeTask) return disposeTask;
       disposed = true;
-      const booked = [...threads.values()];
-      threads.clear();
-      await Promise.all(booked.map((entry) => stopBooked(entry)));
-      events.close();
+      disposeTask = (async () => {
+        await stopAll();
+        events.close();
+      })();
+      return disposeTask;
     }
   };
   return instance;
@@ -28379,7 +28609,7 @@ var executors = [
 ];
 var index_default = definePlugin({
   id: "agent-kimi",
-  apiVersion: 14,
+  apiVersion: 16,
   executors,
   activate(ctx) {
     ctx.log.info("Kimi Code executor ready");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-kimi",
-  "version": "0.2.3130",
+  "version": "0.2.3168",
   "description": "Kimi Code executor: runs `kimi acp` over Agent Client Protocol stdio.",
   "keywords": [
     "ycodium",
@@ -21,8 +21,8 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.3130",
-    "ycodium-acp-executor": "0.2.3130",
+    "@ycodium-ai/plugin-api": "0.2.3168",
+    "ycodium-acp-executor": "0.2.3168",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {