Give the memory back when a local model has been sitting unused

A whisper.cpp or llama.cpp server started for one dictation stayed loaded
until Dikte quit. On this machine that is 1.3 GB of VRAM for large-v3 plus
whatever the cleanup LLM takes, held all day between dictations that last
seconds.

Each Server now carries an idle window. A watcher thread per launch stops the
server once nothing has asked it anything for that long, and the next request
loads it again through serve(), which already starts what is not running.
Settings has one checkbox and one number for both servers, on by default at ten
minutes, and it only appears for a machine that runs a model here. The tray menu
says which models are loaded and offers to unload them now.

Two things the clock alone gets wrong, both held off by a count of requests in
flight:

  * A file or a meeting is one address lookup and then minutes of work, which
    to a clock started at the lookup looks exactly like a model nobody wants.
    api.py and cleanup.py hold the count for the length of the request.

  * The count must survive the start it triggered. cleanup._local takes the
    hold and only then asks for the address, so a cold start happens inside it;
    neither serve() nor _stop_now() resets the count any more.

Unloading by hand runs on the interface's thread, so it asks for the start lock
rather than waiting on it: a model still being read in is refused, the way one
in the middle of a request is, instead of freezing the window for as long as
the load takes.

dikte/app.py

@@ -289,6 +289,11 @@ class Dikte:
         self.update_action.triggered.connect(self.open_release_page)
         self.menu.addAction(self.update_action)
 
+        # Named in _refresh_tray, which is where the loaded models are known.
+        self.unload_action = QAction("", self.menu)
+        self.unload_action.triggered.connect(self.unload_models)
+        self.menu.addAction(self.unload_action)
+
         self.settings_action = QAction(t("Settings…"), self.menu)
         self.settings_action.triggered.connect(self.open_settings)
         self.menu.addAction(self.settings_action)
@@ -303,6 +308,10 @@ class Dikte:
         self.menu.addAction(self.quit_action)
 
         self.tray.setContextMenu(self.menu)
+        # A model unloads itself in the background, so what the unload row says
+        # goes stale between state changes. Refreshed as the menu opens, which
+        # is the only moment anybody reads it.
+        self.menu.aboutToShow.connect(self._refresh_tray)
         self.tray.setToolTip(t("Dikte: ready"))
         self.tray.activated.connect(self._tray_clicked)
         self._refresh_update()
@@ -398,6 +407,21 @@ class Dikte:
         )
         self.ask_cancel_action.setEnabled(self.ask_state == BUSY)
 
+        # A local model holds its memory whether or not anything is using it, so
+        # the menu says which of the two are loaded and offers to give it back.
+        # Hidden on a machine that runs neither: there is nothing to unload and
+        # nothing to report.
+        loaded = [server for server in (ggml.whisper, ggml.llm) if server.running]
+        self.unload_action.setVisible(
+            self.conf["transcribe_provider"] == "local" or self.conf.uses_local_llm()
+        )
+        self.unload_action.setText(
+            t("Unload the models") if len(loaded) > 1
+            else t("Unload the model") if loaded
+            else t("No model loaded")
+        )
+        self.unload_action.setEnabled(bool(loaded))
+
         # The agent speaks through the icon only when dictation has nothing to
         # say, since dictation is the one being waited on in front of a screen.
         if self.state == IDLE and self.ask_state != IDLE:
@@ -1209,6 +1233,18 @@ class Dikte:
         QDesktopServices.openUrl(
             QUrl(release.url if release is not None else update.RELEASES_PAGE))
 
+    def unload_models(self):
+        """Give the memory back now rather than when the idle window closes."""
+        held = [server for server in (ggml.whisper, ggml.llm)
+                if not server.unload()]
+        self._refresh_tray()
+        if held:
+            self.tray.showMessage(
+                "Dikte",
+                t("A model is loading or answering right now. Try again in a "
+                  "moment."),
+                QSystemTrayIcon.MessageIcon.Information, 5000)
+
     # ---- settings ---------------------------------------------------------
 
     def open_settings(self):