fix: align terminal unit contracts with the imported behavior

- Provider install/removal admission moves to request time (revision bumps
  before the commit turn): a newer transaction supersedes stale staged bytes,
  while the per-module turn keeps commits and directory removal in request
  order.
- The remote keeps its exact optimistic position contract: positionTicks is
  the raw pinned value and pause/unpause/stop pin the current base, so an
  optimistic seek target survives stale snapshots; the predicted clock
  remains for media-session consumers.
- The performance monitor test registers an observer, matching the
  sample-only-while-observed lifecycle.

Author: sachk

src/app/RemoteTargetsController.cpp

@@ -643,14 +643,11 @@ void RemoteTargetsController::beginOptimistic(const QVariantMap& command)
     const auto name = command.value("action").toString();
     m_ackSequence.reset();
     if (name == "pause" || name == "unpause" || name == "stop") {
-        // Capture the running clock before the transport changes state: a
+        // Capture the current position before the transport changes state: a
         // stale poll must neither rewind it nor restart an optimistic
-        // unpause's clock, and playback advances even from a zero position.
-        if (!m_position.isEmpty()) {
-            const QString captured = QString::number(predictedPositionTicks());
-            m_optimistic.insert("positionTicks", captured);
-            m_position = captured;
-        }
+        // unpause's clock. An optimistic seek target is already exact.
+        if (!m_position.isEmpty())
+            m_optimistic.insert("positionTicks", m_position);
         m_optimistic.insert("state", name == "pause" ? "paused" : name == "unpause" ? "playing" : "stopped");
     } else if (name == "seek")
         m_optimistic.insert("positionTicks", command.value("positionTicks"));

src/app/RemoteTargetsController.h

@@ -64,12 +64,13 @@ class RemoteTargetsController final : public QObject {
         return m_target;
     }
     QVariantMap state() const;
-    // The running clock: the last accepted position advanced by elapsed time
-    // while the target plays. Zero is a real position, not a frozen clock.
+    // The running clock for media-session consumers: the last accepted
+    // position advanced by elapsed time while the target plays. Zero is a
+    // real position, not a frozen clock.
     qint64 predictedPositionTicks() const;
     QString positionTicks() const
     {
-        return m_position.isEmpty() ? m_position : QString::number(predictedPositionTicks());
+        return m_position;
     }
     QString runtimeTicks() const
     {

src/provider/ProviderRegistry.cpp

@@ -932,6 +932,10 @@ QCoro::Task<void> ProviderRegistry::install(
     if (root.isEmpty())
         throw std::runtime_error("installs_disabled");
     const QString id = package.manifest.id;
+    // Admission spans the request: a newer install or removal supersedes this
+    // one before its bytes can commit, while the turn below keeps commits and
+    // directory removal in request order.
+    const quint64 revision = ++m_installRevisions[id];
     QPromise<void> turn;
     turn.start();
     const QFuture<void> previous = std::exchange(m_installTails[id], turn.future());
@@ -943,7 +947,6 @@ QCoro::Task<void> ProviderRegistry::install(
     if (const auto *existing = module(id);
         existing && ProviderPackage::compareVersions(package.manifest.version, existing->manifest.version) <= 0)
         throw std::runtime_error("install_version_not_newer");
-    const quint64 revision = ++m_installRevisions[id];
     QPointer<ProviderRegistry> guard(this);
     // Only inert files are written in the worker. Admission and activation
     // share the registry thread, so a concurrent replacement cannot slip
@@ -973,14 +976,17 @@ QCoro::Task<void> ProviderRegistry::install(
 
 QCoro::Task<void> ProviderRegistry::uninstall(QString moduleId)
 {
+    // A removal request retires older pending installs immediately, while the
+    // turn keeps its directory removal behind any earlier commit and ahead of
+    // any newer install's activation.
+    ++m_installRevisions[moduleId];
     QPromise<void> turn;
     turn.start();
     const QFuture<void> previous = std::exchange(m_installTails[moduleId], turn.future());
     const auto releaseTurn = qScopeGuard([&turn] { turn.finish(); });
     if (previous.isValid())
         co_await qCoro(previous).result();
     clearGrants(moduleId);
-    ++m_installRevisions[moduleId];
     const ProviderModule *existing = module(moduleId);
     if (!existing || (existing->bundled && !existing->overridesBundled) || existing->native)
         co_return;

tests/diagnostics/SystemPerformanceMonitorTest.cpp

@@ -22,6 +22,10 @@ SPOOL_TEST_MAIN("system-performance-monitor")
 {
     QCoreApplication app(argc, argv);
     Spool::SystemPerformanceMonitor monitor;
+    // Sampling runs only while an observer (the diagnostics overlay) is
+    // registered; the bare monitor holds no thread or counters of its own.
+    QObject overlayObserver;
+    monitor.observe(&overlayObserver);
     std::atomic<qint64> fakeAudioDecodeTimeNs { 0 };
     monitor.setAudioDecodeCpuTimeProvider(
         [&fakeAudioDecodeTimeNs] { return fakeAudioDecodeTimeNs.fetch_add(1'000'000) + 1'000'000; });