@moxt-ai/mobius 0.0.131 → 0.0.132

package/dist/index.js

@@ -31368,6 +31368,48 @@ var RetainedAgentProcesses = class {
   };
 };
 
+// src/acp/runtime-operations.ts
+var RuntimeOperations = class {
+  #shutdown = new AbortController();
+  #pending = /* @__PURE__ */ new Set();
+  #closing = null;
+  run = async (options, operation) => {
+    const signal = AbortSignal.any([options.signal, this.#shutdown.signal]);
+    signal.throwIfAborted();
+    const pending = Promise.resolve().then(() => operation({ ...options, signal }));
+    this.#pending.add(pending);
+    try {
+      const result = await pending;
+      signal.throwIfAborted();
+      return result;
+    } finally {
+      this.#pending.delete(pending);
+    }
+  };
+  close = (release) => {
+    if (this.#closing !== null) {
+      return this.#closing;
+    }
+    this.#shutdown.abort();
+    this.#closing = (async () => {
+      await Promise.allSettled([...this.#pending]);
+      await release();
+    })();
+    return this.#closing;
+  };
+};
+async function waitForPreparation(pending, signal) {
+  signal.throwIfAborted();
+  const cancelled = Promise.withResolvers();
+  const abort = () => cancelled.reject(signal.reason);
+  signal.addEventListener("abort", abort, { once: true });
+  try {
+    return await Promise.race([pending, cancelled.promise]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+
 // src/acp/agent-query-processes.ts
 var AgentQueryProcesses = class {
   #processesByQuery;
@@ -31414,7 +31456,7 @@ var AgentQueryProcesses = class {
   prepare = async (options) => {
     const pending = this.#processesByQuery.pending(options.sessionId);
     if (pending !== void 0) {
-      const runtime2 = await pending;
+      const runtime2 = await waitForPreparation(pending, options.signal);
       if (runtime2.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
         this.#processesByQuery.touch(options.sessionId, runtime2);
         return runtime2.prepared();
@@ -31693,6 +31735,7 @@ var AgentProcessPool = class {
 // src/acp/agent-runtime-manager.ts
 var SESSION_CONTROL_TIMEOUT_MILLISECONDS = 3e4;
 var AgentRuntimeManager = class {
+  #operations = new RuntimeOperations();
   #processes = new AgentProcessPool();
   #executionProcesses = new RetainedAgentProcesses({
     touch: this.#processes.touch,
@@ -31815,8 +31858,8 @@ var AgentRuntimeManager = class {
       return runtime;
     });
   }
-  prepareSession = async (options, metrics = unmeasuredOperationMetrics) => {
-    const stored = metrics.measureSync("session-state-read", () => this.#store.read(options.sessionId));
+  prepareSession = async (options, metrics = unmeasuredOperationMetrics) => this.#operations.run(options, async (options2) => {
+    const stored = metrics.measureSync("session-state-read", () => this.#store.read(options2.sessionId));
     if (stored instanceof DeletedAcpStoredSession) {
       throw new AcpExecutionError(
         "The native Agent session was deleted. Start a new chat.",
@@ -31827,19 +31870,22 @@ var AgentRuntimeManager = class {
     if (stored instanceof FoundAcpStoredSession && this.#nativeOperations.has(`${stored.session.agentId}:${stored.session.nativeSessionId}`)) {
       throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
     }
-    const pending = this.#executionProcesses.pending(options.sessionId);
+    const pending = this.#executionProcesses.pending(options2.sessionId);
     if (pending !== void 0) {
-      const runtime2 = await metrics.measure("session-preparation-wait", async () => await pending);
-      if (runtime2.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
-        this.#executionProcesses.touch(options.sessionId, runtime2);
+      const runtime2 = await metrics.measure(
+        "session-preparation-wait",
+        async () => await waitForPreparation(pending, options2.signal)
+      );
+      if (runtime2.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
+        this.#executionProcesses.touch(options2.sessionId, runtime2);
         return runtime2.prepared();
       }
-      return await this.prepareSession(options, metrics);
+      return await this.prepareSession(options2, metrics);
     }
-    const existing = this.#executionProcesses.get(options.sessionId);
+    const existing = this.#executionProcesses.get(options2.sessionId);
     if (existing !== void 0) {
-      if (existing.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
-        this.#executionProcesses.touch(options.sessionId, existing);
+      if (existing.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
+        this.#executionProcesses.touch(options2.sessionId, existing);
         return existing.prepared();
       }
       if (!existing.canRebind()) {
@@ -31849,85 +31895,91 @@ var AgentRuntimeManager = class {
           "session_identity_mismatch"
         );
       }
-      const runtime2 = await this.#replacePreparation(existing, options, metrics);
+      const runtime2 = await this.#replacePreparation(existing, options2, metrics);
       return runtime2.prepared();
     }
-    const runtime = await this.#startPreparation(options, metrics);
+    const runtime = await this.#startPreparation(options2, metrics);
     return runtime.prepared();
-  };
+  });
   /**
    * Opens a short-lived native ACP session only to read the local Agent's
    * authoritative settings. Its identity and store are private to this
    * operation and never become a Mobius Session.
    */
-  inspectAgentSettings = async (options) => await this.#processes.runTransient(
-    options.signal,
-    async () => await AgentSession.start(
-      {
-        ...options,
-        sessionId: `agent-settings-${crypto.randomUUID()}`
+  inspectAgentSettings = async (options) => this.#operations.run(options, async (options2) => {
+    return await this.#processes.runTransient(
+      options2.signal,
+      async () => await AgentSession.start(
+        {
+          ...options2,
+          sessionId: `agent-settings-${crypto.randomUUID()}`
+        },
+        () => this.#agentSettingsObserver,
+        new MemoryAcpSessionStore()
+      ),
+      async (runtime) => {
+        const prepared = runtime.prepared();
+        const model = options2.model;
+        const configOptions = model === void 0 ? prepared.configOptions : await runtime.configure({
+          ...options2,
+          booleanValue: false,
+          configId: prepared.configOptions.find(
+            (option) => option.id === "model" || option.category === "model"
+          )?.id ?? "model",
+          requestId: "agent-settings-model",
+          sessionId: `agent-settings-${crypto.randomUUID()}`,
+          value: model,
+          valueType: "select"
+        });
+        return new AcpAgentSettingsSnapshot(prepared.agentName, prepared.agentVersion, configOptions);
       },
-      () => this.#agentSettingsObserver,
-      new MemoryAcpSessionStore()
-    ),
-    async (runtime) => {
-      const prepared = runtime.prepared();
-      const model = options.model;
-      const configOptions = model === void 0 ? prepared.configOptions : await runtime.configure({
-        ...options,
-        booleanValue: false,
-        configId: prepared.configOptions.find(
-          (option) => option.id === "model" || option.category === "model"
-        )?.id ?? "model",
-        requestId: "agent-settings-model",
-        sessionId: `agent-settings-${crypto.randomUUID()}`,
-        value: model,
-        valueType: "select"
-      });
-      return new AcpAgentSettingsSnapshot(prepared.agentName, prepared.agentVersion, configOptions);
-    },
-    async (runtime) => await runtime.close()
-  );
+      async (runtime) => await runtime.close()
+    );
+  });
   /**
    * Retained for Agents that expose a separate persisted configuration channel.
    * Use inspectAgentSettings for Agent-scoped settings discovery.
    */
-  inspectSession = async (options, metrics = unmeasuredOperationMetrics) => {
-    if (this.#executionProcesses.pending(options.sessionId) !== void 0 || this.#executionProcesses.get(options.sessionId) !== void 0) {
-      throw new AcpExecutionError("The configuration inspection session is already in use", {}, "session_busy");
+  inspectSession = async (options, metrics = unmeasuredOperationMetrics) => this.#operations.run(options, async (options2) => {
+    if (this.#executionProcesses.pending(options2.sessionId) !== void 0 || this.#executionProcesses.get(options2.sessionId) !== void 0) {
+      throw new AcpExecutionError(
+        "The configuration inspection session is already in use",
+        {},
+        "session_busy"
+      );
     }
-    return await this.#executionProcesses.use(options.sessionId, async () => {
-      const runtime = await this.#startPreparation(options, metrics);
+    return await this.#executionProcesses.use(options2.sessionId, async () => {
+      const runtime = await this.#startPreparation(options2, metrics);
       try {
         return runtime.prepared();
       } finally {
         try {
-          await this.#retireSessionProcess(options.sessionId, runtime, async () => await runtime.close());
+          await this.#retireSessionProcess(options2.sessionId, runtime, async () => await runtime.close());
         } finally {
-          this.#store.remove(options.sessionId);
+          this.#store.remove(options2.sessionId);
         }
       }
     });
-  };
-  prepareExecutionSession = async (options) => {
-    const pending = this.#executionProcesses.pending(options.sessionId);
+  });
+  prepareExecutionSession = async (options) => this.#operations.run(options, async (options2) => {
+    const pending = this.#executionProcesses.pending(options2.sessionId);
     if (pending !== void 0) {
-      await pending;
-      return await this.prepareExecutionSession(options);
+      await waitForPreparation(pending, options2.signal);
+      return await this.prepareExecutionSession(options2);
     }
-    const existing = this.#executionProcesses.get(options.sessionId);
+    const existing = this.#executionProcesses.get(options2.sessionId);
     if (existing === void 0) {
-      return (await this.#startPreparation(options)).prepared();
+      return (await this.#startPreparation(options2)).prepared();
     }
-    if (!existing.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
+    if (!existing.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
       throw new AcpExecutionError(
         "The agent or workspace cannot change after a conversation has started",
         {},
         "session_identity_mismatch"
       );
     }
-    if (existing.usesEnvironment(options.agent.environment)) {
-      this.#executionProcesses.touch(options.sessionId, existing);
+    if (existing.usesEnvironment(options2.agent.environment)) {
+      this.#executionProcesses.touch(options2.sessionId, existing);
       return existing.prepared();
     }
     if (existing.hasRunningTurn()) {
@@ -31937,15 +31989,15 @@ var AgentRuntimeManager = class {
         "session_busy"
       );
     }
-    return (await this.#replaceExecutionPreparation(existing, options)).prepared();
-  };
-  prepareNativeSessionBrowser = (options) => this.#queryProcesses.prepare(options);
-  configureSession = async (options) => {
-    return await this.#executionProcesses.use(options.sessionId, async () => {
-      const runtime = await this.ensureSession(options);
-      return await runtime.configure(options);
+    return (await this.#replaceExecutionPreparation(existing, options2)).prepared();
+  });
+  prepareNativeSessionBrowser = (options) => this.#operations.run(options, (scoped) => this.#queryProcesses.prepare(scoped));
+  configureSession = async (options) => this.#operations.run(options, async (options2) => {
+    return await this.#executionProcesses.use(options2.sessionId, async () => {
+      const runtime = await this.ensureSession(options2);
+      return await runtime.configure(options2);
     });
-  };
+  });
   cancelPrompt = async (sessionId) => {
     await this.#executions.cancel(sessionId, async () => {
       const runtime = this.#executionProcesses.get(sessionId);
@@ -31960,19 +32012,19 @@ var AgentRuntimeManager = class {
       }
     });
   };
-  steerPrompt = async (options) => {
-    if (this.#executions.command(options.sessionId) !== options.targetCommandId) {
+  steerPrompt = async (options) => this.#operations.run(options, async (options2) => {
+    if (this.#executions.command(options2.sessionId) !== options2.targetCommandId) {
       throw new AcpExecutionError("The target turn is no longer active", {}, "steering_target_unavailable");
     }
-    const pending = this.#executionProcesses.pending(options.sessionId);
+    const pending = this.#executionProcesses.pending(options2.sessionId);
     if (pending !== void 0) {
-      await pending;
+      await waitForPreparation(pending, options2.signal);
     }
-    if (this.#executions.command(options.sessionId) !== options.targetCommandId) {
+    if (this.#executions.command(options2.sessionId) !== options2.targetCommandId) {
       throw new AcpExecutionError("The target turn is no longer active", {}, "steering_target_unavailable");
     }
-    const runtime = this.#executionProcesses.get(options.sessionId);
-    if (runtime === void 0 || !runtime.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
+    const runtime = this.#executionProcesses.get(options2.sessionId);
+    if (runtime === void 0 || !runtime.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
       throw new AcpExecutionError(
         "The target turn execution context is unavailable",
         {},
@@ -31989,8 +32041,8 @@ var AgentRuntimeManager = class {
     deadline.unref();
     try {
       return await runtime.steer({
-        ...options,
-        signal: AbortSignal.any([options.signal, deadlineController.signal])
+        ...options2,
+        signal: AbortSignal.any([options2.signal, deadlineController.signal])
       });
     } catch (error62) {
       if (error62 instanceof AcpExecutionError) {
@@ -32000,44 +32052,44 @@ var AgentRuntimeManager = class {
     } finally {
       clearTimeout(deadline);
     }
-  };
-  runPrompt = async (options) => {
-    const stored = this.#store.read(options.sessionId);
+  });
+  runPrompt = async (options) => this.#operations.run(options, async (options2) => {
+    const stored = this.#store.read(options2.sessionId);
     if (stored instanceof FoundAcpStoredSession && this.#nativeOperations.has(`${stored.session.agentId}:${stored.session.nativeSessionId}`)) {
       throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
     }
-    this.#executions.begin(options.sessionId, options.commandId);
+    this.#executions.begin(options2.sessionId, options2.commandId);
     try {
-      if (this.#executions.cancellation(options.sessionId) !== void 0) {
+      if (this.#executions.cancellation(options2.sessionId) !== void 0) {
         return { stopReason: "cancelled" };
       }
-      const runtime = await this.ensureSession(options);
-      if (this.#nativeOperations.has(`${options.agent.id}:${runtime.nativeSessionId()}`)) {
+      const runtime = await this.ensureSession(options2);
+      if (this.#nativeOperations.has(`${options2.agent.id}:${runtime.nativeSessionId()}`)) {
         throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
       }
-      if (this.#executions.cancellation(options.sessionId) !== void 0) {
+      if (this.#executions.cancellation(options2.sessionId) !== void 0) {
         return { stopReason: "cancelled" };
       }
       try {
-        const result = await runtime.prompt(options);
-        return this.#executions.cancellation(options.sessionId) !== void 0 ? { stopReason: "cancelled" } : result;
+        const result = await runtime.prompt(options2);
+        return this.#executions.cancellation(options2.sessionId) !== void 0 ? { stopReason: "cancelled" } : result;
       } catch (error62) {
-        if (this.#executions.cancellation(options.sessionId) !== void 0) {
-          await this.#executions.cancellation(options.sessionId);
+        if (this.#executions.cancellation(options2.sessionId) !== void 0) {
+          await this.#executions.cancellation(options2.sessionId);
           return { stopReason: "cancelled" };
         }
         throw error62;
       }
     } catch (error62) {
-      const failedRuntime = this.#executionProcesses.get(options.sessionId);
+      const failedRuntime = this.#executionProcesses.get(options2.sessionId);
       if (failedRuntime !== void 0) {
         await this.#retireSessionProcess(
-          options.sessionId,
+          options2.sessionId,
           failedRuntime,
           async () => await failedRuntime.close()
         );
       }
-      if (this.#executions.cancellation(options.sessionId) !== void 0) {
+      if (this.#executions.cancellation(options2.sessionId) !== void 0) {
         return { stopReason: "cancelled" };
       }
       if (error62 instanceof AcpExecutionError) {
@@ -32048,14 +32100,14 @@ var AgentRuntimeManager = class {
       });
     } finally {
       try {
-        await this.#executions.cancellation(options.sessionId);
+        await this.#executions.cancellation(options2.sessionId);
       } finally {
-        this.#executions.finish(options.sessionId, options.commandId);
-        this.#executionProcesses.touch(options.sessionId);
+        this.#executions.finish(options2.sessionId, options2.commandId);
+        this.#executionProcesses.touch(options2.sessionId);
         this.#processes.notifyChanged();
       }
     }
-  };
+  });
   respondPermission = async (options) => {
     const runtime = this.#executionProcesses.get(options.sessionId);
     if (runtime === void 0) {
@@ -32070,7 +32122,7 @@ var AgentRuntimeManager = class {
     }
     await runtime.respondElicitation(options);
   };
-  close = async () => {
+  close = async () => this.#operations.close(async () => {
     const sessions = [...this.#executionProcesses.entries()];
     await Promise.all([
       ...sessions.map(
@@ -32078,23 +32130,23 @@ var AgentRuntimeManager = class {
       ),
       this.#queryProcesses.close()
     ]);
-  };
+  });
   findSessions = (sessionIds) => sessionIds.flatMap((sessionId) => {
     const stored = this.#store.read(sessionId);
     return stored instanceof FoundAcpStoredSession ? [stored.session] : [];
   });
   findLinkedSessions = (agentId, nativeSessionId) => this.#store.findNative(agentId, nativeSessionId);
   hasPreparedSession = (sessionId, agentId, cwd, additionalDirectories) => this.#executionProcesses.get(sessionId)?.belongsTo(agentId, cwd, additionalDirectories) === true;
-  createNativeSession = async (options) => {
+  createNativeSession = async (options) => this.#operations.run(options, async (options2) => {
     const temporarySessionId = `new-${crypto.randomUUID()}`;
-    const temporaryOptions = { ...options, sessionId: temporarySessionId };
+    const temporaryOptions = { ...options2, sessionId: temporarySessionId };
     return await this.#executionProcesses.use(temporarySessionId, async () => {
       try {
         const runtime = await this.#startPreparation(temporaryOptions);
         let adopted = false;
         try {
           const nativeSessionId = runtime.nativeSessionId();
-          if (!isNativeChatSessionId(options.agent.id, nativeSessionId) || this.#executionProcesses.get(nativeSessionId) !== void 0 || !(this.#store.read(nativeSessionId) instanceof MissingAcpStoredSession)) {
+          if (!isNativeChatSessionId(options2.agent.id, nativeSessionId) || this.#executionProcesses.get(nativeSessionId) !== void 0 || !(this.#store.read(nativeSessionId) instanceof MissingAcpStoredSession)) {
             throw new AcpExecutionError(
               "The Agent returned an invalid new Session ID",
               {},
@@ -32120,36 +32172,36 @@ var AgentRuntimeManager = class {
         this.#store.remove(temporarySessionId);
       }
     });
-  };
-  ensureSession = async (options) => {
-    const existing = this.#executionProcesses.get(options.sessionId);
+  });
+  ensureSession = async (options) => this.#operations.run(options, async (options2) => {
+    const existing = this.#executionProcesses.get(options2.sessionId);
     if (existing !== void 0) {
-      if (!existing.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
+      if (!existing.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
         throw new AcpExecutionError(
           "The agent or workspace cannot change after a conversation has started",
           {},
           "session_identity_mismatch"
         );
       }
-      this.#executionProcesses.touch(options.sessionId, existing);
+      this.#executionProcesses.touch(options2.sessionId, existing);
       return existing;
     }
-    await this.prepareSession(options);
-    const started = this.#executionProcesses.get(options.sessionId);
+    await this.prepareSession(options2);
+    const started = this.#executionProcesses.get(options2.sessionId);
     if (started === void 0) {
       throw new AcpExecutionError("ACP session did not start");
     }
     return started;
-  };
-  listNativeSessions = async (options, cursor) => {
+  });
+  listNativeSessions = async (options, cursor) => this.#operations.run(options, async (options2) => {
     return await this.#queryProcesses.use(
-      options,
-      async (runtime) => await runtime.listNativeSessions(cursor, options.signal)
+      options2,
+      async (runtime) => await runtime.listNativeSessions(cursor, options2.signal)
     );
-  };
-  previewNativeSession = async (options, nativeSessionId) => {
-    const key = `${options.agent.id}:${nativeSessionId}`;
-    const linked = this.#store.findNative(options.agent.id, nativeSessionId);
+  });
+  previewNativeSession = async (options, nativeSessionId) => this.#operations.run(options, async (options2) => {
+    const key = `${options2.agent.id}:${nativeSessionId}`;
+    const linked = this.#store.findNative(options2.agent.id, nativeSessionId);
     if (this.#nativeOperations.has(key) || linked.some(
       (entry) => this.#executions.command(entry.sessionId) !== void 0 || this.#executionProcesses.pending(entry.sessionId) !== void 0
     )) {
@@ -32161,18 +32213,18 @@ var AgentRuntimeManager = class {
     }
     this.#nativeOperations.add(key);
     try {
-      return await this.#queryProcesses.preview(options, nativeSessionId);
+      return await this.#queryProcesses.preview(options2, nativeSessionId);
     } finally {
       this.#nativeOperations.delete(key);
     }
-  };
-  loadSessionHistory = async (options) => {
-    return await this.#executionProcesses.use(options.sessionId, async () => {
-      const runtime = await this.ensureSession(options);
-      const stored = this.#store.read(options.sessionId);
+  });
+  loadSessionHistory = async (options) => this.#operations.run(options, async (options2) => {
+    return await this.#executionProcesses.use(options2.sessionId, async () => {
+      const runtime = await this.ensureSession(options2);
+      const stored = this.#store.read(options2.sessionId);
       if (stored instanceof FoundAcpStoredSession && this.#nativeHistoryReader !== null) {
         const history = await this.#nativeHistoryReader.read(
-          options,
+          options2,
           stored.session.nativeSessionId,
           runtime.nativeHistoryTurn
         );
@@ -32180,15 +32232,15 @@ var AgentRuntimeManager = class {
           return history;
         }
       }
-      return await runtime.loadHistory(options.signal);
+      return await runtime.loadHistory(options2.signal);
     });
-  };
-  openNativeSession = async (options, origin) => {
-    const key = `${options.agent.id}:${origin.nativeSessionId}`;
+  });
+  openNativeSession = async (options, origin) => this.#operations.run(options, async (options2) => {
+    const key = `${options2.agent.id}:${origin.nativeSessionId}`;
     if (this.#nativeOperations.has(key)) {
       throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
     }
-    const linked = this.#store.findNative(options.agent.id, origin.nativeSessionId);
+    const linked = this.#store.findNative(options2.agent.id, origin.nativeSessionId);
     if (linked.some(
       (entry) => this.#executions.command(entry.sessionId) !== void 0 || this.#executionProcesses.pending(entry.sessionId) !== void 0
     )) {
@@ -32202,7 +32254,7 @@ var AgentRuntimeManager = class {
     if (origin.kind === "import" && existing !== void 0) {
       return await this.#executionProcesses.use(existing.sessionId, async () => {
         const runtime = await this.ensureSession({
-          ...options,
+          ...options2,
           sessionId: existing.sessionId
         });
         if (this.#executions.command(existing.sessionId) !== void 0 || this.#nativeOperations.has(key)) {
@@ -32224,18 +32276,22 @@ var AgentRuntimeManager = class {
         }
       });
     }
-    if (this.#executionProcesses.get(options.sessionId) !== void 0 || this.#executionProcesses.pending(options.sessionId) !== void 0 || this.#store.read(options.sessionId) instanceof FoundAcpStoredSession || this.#store.read(options.sessionId) instanceof DeletedAcpStoredSession) {
-      throw new AcpExecutionError("The destination conversation already exists", {}, "session_identity_mismatch");
+    if (this.#executionProcesses.get(options2.sessionId) !== void 0 || this.#executionProcesses.pending(options2.sessionId) !== void 0 || this.#store.read(options2.sessionId) instanceof FoundAcpStoredSession || this.#store.read(options2.sessionId) instanceof DeletedAcpStoredSession) {
+      throw new AcpExecutionError(
+        "The destination conversation already exists",
+        {},
+        "session_identity_mismatch"
+      );
     }
-    return await this.#executionProcesses.use(options.sessionId, async () => {
+    return await this.#executionProcesses.use(options2.sessionId, async () => {
       this.#nativeOperations.add(key);
       try {
-        const runtime = await this.#startPreparation({ ...options, origin });
-        const openedKey = `${options.agent.id}:${runtime.nativeSessionId()}`;
+        const runtime = await this.#startPreparation({ ...options2, origin });
+        const openedKey = `${options2.agent.id}:${runtime.nativeSessionId()}`;
         this.#nativeOperations.add(openedKey);
         try {
           return {
-            sessionId: options.sessionId,
+            sessionId: options2.sessionId,
             prepared: runtime.prepared()
           };
         } finally {
@@ -32243,11 +32299,11 @@ var AgentRuntimeManager = class {
           this.#processes.notifyChanged();
         }
       } catch (error62) {
-        this.#store.remove(options.sessionId);
-        const runtime = this.#executionProcesses.get(options.sessionId);
+        this.#store.remove(options2.sessionId);
+        const runtime = this.#executionProcesses.get(options2.sessionId);
         if (runtime !== void 0) {
           await this.#retireSessionProcess(
-            options.sessionId,
+            options2.sessionId,
             runtime,
             async () => await runtime.closeProcess()
           );
@@ -32257,11 +32313,11 @@ var AgentRuntimeManager = class {
         this.#nativeOperations.delete(key);
       }
     });
-  };
-  deleteNativeSession = async (options, nativeSessionId) => {
-    return await this.#queryProcesses.use(options, async (runtime) => {
-      const key = `${options.agent.id}:${nativeSessionId}`;
-      const linked = this.#store.findNative(options.agent.id, nativeSessionId);
+  });
+  deleteNativeSession = async (options, nativeSessionId) => this.#operations.run(options, async (options2) => {
+    return await this.#queryProcesses.use(options2, async (runtime) => {
+      const key = `${options2.agent.id}:${nativeSessionId}`;
+      const linked = this.#store.findNative(options2.agent.id, nativeSessionId);
       if (this.#nativeOperations.has(key) || linked.some(
         (entry) => this.#executions.command(entry.sessionId) !== void 0 || this.#executionProcesses.pending(entry.sessionId) !== void 0
       )) {
@@ -32279,11 +32335,11 @@ var AgentRuntimeManager = class {
             await this.#retireSessionProcess(entry.sessionId, active, async () => await active.close());
           }
         }
-        options.signal.throwIfAborted();
-        await runtime.deleteNativeSession(nativeSessionId, options.signal);
-        const deleted = this.#store.markDeleted(options.agent.id, nativeSessionId);
+        options2.signal.throwIfAborted();
+        await runtime.deleteNativeSession(nativeSessionId, options2.signal);
+        const deleted = this.#store.markDeleted(options2.agent.id, nativeSessionId);
         if (runtime.nativeSessionId() === nativeSessionId) {
-          await this.#queryProcesses.retire(options.sessionId, runtime);
+          await this.#queryProcesses.retire(options2.sessionId, runtime);
         }
         return deleted;
       } finally {
@@ -32291,7 +32347,7 @@ var AgentRuntimeManager = class {
         this.#processes.notifyChanged();
       }
     });
-  };
+  });
 };
 
 // src/acp/run-prompt.ts