fix(desktop): harden Notch chat and PTT reliability (#10125)

## Summary

- preserve the user-resized Notch chat frame when macOS changes Spaces
- keep streaming output from reclaiming the viewport after a reader
scrolls away from the live edge
- restore the canonical frame for non-chat Notch surfaces after a Space
switch
- retain completed and failed tool rows as durable chat progress in
compact, collapsed-by-default groups whose step count updates while work
continues, while keeping the structured agent card as the sole
spawned-agent entrypoint
- use a shared thin composer shell and transcript fade in regular and
Notch chat, reduce the regular-chat header to one compact control row,
and add a persistent Home action there
- pass a deduplicated, compact skill catalog to chat, keep CLAUDE.md
reference-only, and search overflow skills only when a specialized
workflow is relevant
- give active tools a 90-second no-progress watchdog that preserves the
tool-stall terminal reason; use the 60-second generic watchdog only for
a silent bridge with no active tool
- correlate the desktop, agent, and chat route with an opaque request
ID, and retry terminal journal projection once when needed
- keep Push-to-Talk on its native voice path when screen capture is
temporarily unavailable immediately after Screen Recording is granted
- prevent long named-bundle titles from clipping the Screen Recording
drag helper, and coalesce idle PTT context refreshes so streaming chat
does not churn the warm voice socket

## Product invariants

- INV-AGENT-*
- INV-AUTH-1
- INV-CHAT-1
- INV-VOICE-1
- INV-INT-1

## Verification

- `desktop/macos/scripts/agent-logic-harness.sh` — passed (Swift
lifecycle, agent runtime, and pi extension suites)
- `xcrun swift test --package-path Desktop --filter
ChatSkillCatalogTests` — passed (2 tests)
- `xcrun swift test --package-path Desktop --filter
AgentPillLifecycleTests/testFloatingAgentToolCallsUseCompactOneLinePresentation`
— passed
- `npm run build` and `node --experimental-strip-types
scripts/generate-tool-surfaces.mjs --check` in `desktop/macos/agent` —
passed
- `npx vitest run tests/node-tools.test.ts
tests/omi-tool-manifest.test.ts` — passed (20 tests)
- `npx --yes tsx --test index.test.ts` in
`desktop/macos/pi-mono-extension` — passed
- `make preflight` and the bounded pre-push gate — passed
- `git diff --check` — passed
- rebuilt `/Applications/omi-tool-stall-reliability.app` from `ae2e79f`;
health check confirmed development backend and agent protocol 2, and
automation confirmed Chat's Home button returns to the dashboard
- `xcrun swift test --package-path Desktop --filter
ScreenRecordingPermissionPolicyTests` — passed (15 tests)
- `xcrun swift test --package-path Desktop --filter
RealtimeHubSessionHandoffPolicyTests` — passed (12 tests)
- fast-rebuilt `/Applications/omi-tool-stall-reliability.app` from
`f9d5a81`; health check confirmed the development backend and runtime
protocol 2

Failure-Class: none

Author: Git-on-my-level

.github/scripts/product_file_line_count_ratchet_baseline/desktop-swift-mainwindow.json

@@ -1,14 +1,14 @@
 {
   "files": {
-    "desktop/macos/Desktop/Sources/MainWindow/Components/ChatBubble.swift": 1939,
+    "desktop/macos/Desktop/Sources/MainWindow/Components/ChatBubble.swift": 1926,
     "desktop/macos/Desktop/Sources/MainWindow/Pages/AppsPage.swift": 3643,
     "desktop/macos/Desktop/Sources/MainWindow/Pages/DashboardPage.swift": 4448,
     "desktop/macos/Desktop/Sources/MainWindow/Pages/MemoriesPage.swift": 3298,
     "desktop/macos/Desktop/Sources/MainWindow/Pages/TasksPage.swift": 5518,
     "desktop/macos/Desktop/Sources/MainWindow/SidebarView.swift": 1570
   },
   "raise_justifications": {
-    "desktop/macos/Desktop/Sources/MainWindow/Components/ChatBubble.swift": "Syncs the local rating shadow to external message.rating changes so an un-rate tap is no longer swallowed after a server refresh.",
+    "desktop/macos/Desktop/Sources/MainWindow/Components/ChatBubble.swift": "Keeps all chat tool groups compact and collapsed while streamed steps increment, with an explicit expansion policy, fixed collapsed height, and regression coverage.",
     "desktop/macos/Desktop/Sources/MainWindow/Pages/AppsPage.swift": "Rebase reconciliation applies the pinned swift-format to the main-branch app-detail safety fixes; runtime behavior is unchanged.",
     "desktop/macos/Desktop/Sources/MainWindow/Pages/DashboardPage.swift": "Pinned swift-format normalizes line layout without changing this source's runtime behavior.",
     "desktop/macos/Desktop/Sources/MainWindow/Pages/MemoriesPage.swift": "Bridge memory search now awaits the active initial or pagination projection before refreshing, preventing an immediate post-navigation marker search from using stale lifecycle capability state.",

.github/scripts/product_file_line_count_ratchet_baseline/desktop-swift-providers.json

@@ -1,10 +1,10 @@
 {
   "files": {
-    "desktop/macos/Desktop/Sources/Providers/ChatProvider.swift": 6197,
+    "desktop/macos/Desktop/Sources/Providers/ChatProvider.swift": 6200,
     "desktop/macos/Desktop/Sources/Providers/ChatToolExecutor.swift": 2861
   },
   "raise_justifications": {
-    "desktop/macos/Desktop/Sources/Providers/ChatProvider.swift": "Ambient turns without Screen Recording carry an honest screen-unavailable payload instead of silence.",
+    "desktop/macos/Desktop/Sources/Providers/ChatProvider.swift": "The activity-aware watchdog must remain beside the send-generation, bridge-interrupt, and journal-terminalization boundary it atomically owns; extracting it would split that recovery invariant.",
     "desktop/macos/Desktop/Sources/Providers/ChatToolExecutor.swift": "Already-granted permissions no longer reopen System Settings: screen-recording and full-disk-access requests gate their Settings/drag-card opens behind the granted result."
   },
   "threshold": 1500

desktop/macos/Backend-Rust/src/routes/chat/route.rs

@@ -58,11 +58,58 @@ pub(super) fn chat_metering_response(decision: &RateDecision) -> Option<Response
 /// cap, which covers all realistic floating-bar sessions. History trimming
 /// is tracked separately as the longer-term fix.
 const CHAT_COMPLETIONS_MAX_BODY_SIZE: usize = 16 * 1024 * 1024;
+
+const OMI_REQUEST_ID_HEADER: &str = "x-omi-request-id";
+const RESPONSE_REQUEST_ID_HEADER: &str = "x-request-id";
+
+fn inbound_request_id(headers: &HeaderMap) -> String {
+    headers
+        .get(OMI_REQUEST_ID_HEADER)
+        .and_then(|value| value.to_str().ok())
+        .filter(|value| {
+            !value.is_empty()
+                && value.len() <= 128
+                && value
+                    .bytes()
+                    .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_'))
+        })
+        .map(ToOwned::to_owned)
+        .unwrap_or_else(|| ulid::Ulid::new().to_string())
+}
+
+fn attach_request_id(response: &mut Response, request_id: &str) {
+    if let Ok(value) = request_id.parse() {
+        response
+            .headers_mut()
+            .insert(RESPONSE_REQUEST_ID_HEADER, value);
+    }
+}
+
 async fn chat_completions(
     State(state): State<AppState>,
     user: PaywalledAuthUser,
     headers: HeaderMap,
     Json(req): Json<ChatCompletionRequest>,
+) -> Result<Response, StatusCode> {
+    let request_id = inbound_request_id(&headers);
+    tracing::info!(
+        event = "chat_completion_request",
+        request_id = %request_id,
+        streaming = req.stream,
+        "chat completion received"
+    );
+    let response = chat_completions_inner(state, user, headers, req).await;
+    response.map(|mut response| {
+        attach_request_id(&mut response, &request_id);
+        response
+    })
+}
+
+async fn chat_completions_inner(
+    state: AppState,
+    user: PaywalledAuthUser,
+    headers: HeaderMap,
+    req: ChatCompletionRequest,
 ) -> Result<Response, StatusCode> {
     let byok_stripped = user.byok_stripped;
     let user: AuthUser = user.into();
@@ -207,3 +254,44 @@ pub(crate) fn chat_completions_routes() -> Router<AppState> {
         .route("/v2/chat/completions", post(chat_completions))
         .layer(DefaultBodyLimit::max(CHAT_COMPLETIONS_MAX_BODY_SIZE))
 }
+
+#[cfg(test)]
+mod tests {
+    use axum::{
+        body::Body,
+        http::{HeaderMap, HeaderValue},
+        response::Response,
+    };
+
+    use super::{attach_request_id, inbound_request_id};
+
+    #[test]
+    fn preserves_a_valid_opaque_request_id() {
+        let mut headers = HeaderMap::new();
+        headers.insert("x-omi-request-id", HeaderValue::from_static("req_01AB-cd"));
+
+        assert_eq!(inbound_request_id(&headers), "req_01AB-cd");
+    }
+
+    #[test]
+    fn replaces_invalid_request_ids_without_echoing_them() {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            "x-omi-request-id",
+            HeaderValue::from_static("request id with spaces"),
+        );
+
+        let request_id = inbound_request_id(&headers);
+        assert_ne!(request_id, "request id with spaces");
+        assert!(request_id.parse::<ulid::Ulid>().is_ok());
+    }
+
+    #[test]
+    fn echoes_the_resolved_request_id_on_the_response() {
+        let mut response = Response::new(Body::empty());
+
+        attach_request_id(&mut response, "req_01AB-cd");
+
+        assert_eq!(response.headers()["x-request-id"], "req_01AB-cd");
+    }
+}

desktop/macos/Desktop/Sources/Chat/ChatTurnLifecycle.swift

@@ -155,6 +155,14 @@ final class ChatJournalWriteCoordinator {
     return true
   }
 
+  /// Retry one idempotent terminal journal operation after transient local
+  /// projection failure. The caller must first claim terminalization ownership;
+  /// this helper never reopens that ownership or permits a streaming update.
+  func retryTerminalization(_ operation: @MainActor () async -> Bool) async -> Bool {
+    if await operation() { return true }
+    return await operation()
+  }
+
   func cancelAll() {
     for task in updateTasks.values { task.cancel() }
     updateTasks.removeAll()

desktop/macos/Desktop/Sources/Chat/StallDetector.swift

@@ -7,8 +7,8 @@ import Foundation
 /// Two timers track independently:
 ///   - **Inter-event gap** — ms since the last event of any kind.
 ///     Captures "the bridge stopped streaming."
-///   - **Per-tool duration** — ms since each in-flight tool started.
-///     Captures "this specific tool is hanging."
+///   - **Per-tool no-progress gap** — ms since each in-flight tool last
+///     reported progress. Captures "this specific tool stopped moving."
 ///
 /// The detector is pure logic: time is passed in as a parameter on
 /// every operation, so tests can drive it instantly without wall-clock
@@ -43,6 +43,11 @@ actor StallDetector {
     /// per-tool timer for `id` (typically the `toolUseId`).
     case toolStarted(id: String)
 
+    /// A `tool_activity` progress update for an in-flight tool. This refreshes
+    /// only the tool's no-progress clock; it never changes the tool's original
+    /// start time used by duration diagnostics.
+    case toolProgress(id: String)
+
     /// A `tool_activity` with status `completed` (or `failed` /
     /// `cancelled`) arrived. Clears the per-tool timer for `id` and
     /// emits a transition back to `.running` if the tool was promoted.
@@ -71,6 +76,7 @@ actor StallDetector {
 
   /// In-flight tools keyed by `toolUseId`. Removed on completion.
   private var toolStartedAtMs: [String: Int] = [:]
+  private var toolLastProgressAtMs: [String: Int] = [:]
   private var toolStates: [String: State] = [:]
 
   // MARK: - Init
@@ -97,15 +103,21 @@ actor StallDetector {
     toolStates
   }
 
-  /// IDs of tools that have exceeded a hard execution budget.  The caller owns
-  /// the recovery action (for example, interrupting the bridge); the detector
-  /// remains pure and does not perform side effects itself.
-  func toolIdsExceeding(durationMs: Int, atMs: Int) -> [String] {
-    toolStartedAtMs.compactMap { id, startedAt in
-      atMs - startedAt >= durationMs ? id : nil
+  /// IDs of tools that have gone too long without a progress update. The caller
+  /// owns the recovery action (for example, interrupting the bridge); the
+  /// detector remains pure and does not perform side effects itself.
+  func toolIdsWithoutProgress(durationMs: Int, atMs: Int) -> [String] {
+    toolLastProgressAtMs.compactMap { id, lastProgressAt in
+      atMs - lastProgressAt >= durationMs ? id : nil
     }
   }
 
+  /// A generic bridge timeout may fire only after a full quiet interval with
+  /// no tool in flight. Active tools have their own no-progress watchdog.
+  func isSilentWithoutActiveTools(durationMs: Int, atMs: Int) -> Bool {
+    toolStartedAtMs.isEmpty && atMs - lastEventAtMs >= durationMs
+  }
+
   // MARK: - Observation
 
   /// Record an event at simulated time `atMs` and return any state
@@ -153,11 +165,18 @@ actor StallDetector {
     case .toolStarted(let id):
       if toolStartedAtMs[id] == nil {
         toolStartedAtMs[id] = atMs
+        toolLastProgressAtMs[id] = atMs
         toolStates[id] = .running
       }
 
+    case .toolProgress(let id):
+      if toolStartedAtMs[id] != nil {
+        toolLastProgressAtMs[id] = atMs
+      }
+
     case .toolCompleted(let id):
       toolStartedAtMs.removeValue(forKey: id)
+      toolLastProgressAtMs.removeValue(forKey: id)
       let old = toolStates.removeValue(forKey: id) ?? .running
       if old != .running {
         // Tool completed while promoted (slow/stalled → done) — UI
@@ -181,9 +200,9 @@ actor StallDetector {
     }
 
     // Per-tool timers.
-    for (toolId, startedAt) in toolStartedAtMs {
-      let duration = atMs - startedAt
-      let newToolState = promotedState(forElapsedMs: duration)
+    for (toolId, lastProgressAt) in toolLastProgressAtMs {
+      let noProgressGap = atMs - lastProgressAt
+      let newToolState = promotedState(forElapsedMs: noProgressGap)
       let oldToolState = toolStates[toolId] ?? .running
       if newToolState != oldToolState {
         transitions.append(.tool(id: toolId, from: oldToolState, to: newToolState))

desktop/macos/Desktop/Sources/Chat/StallThresholds.swift

@@ -1,14 +1,14 @@
 import Foundation
 
 /// Time thresholds the `StallDetector` uses to promote inter-event gaps
-/// and per-tool durations between `.running`, `.slow`, and `.stalled`.
+/// and per-tool no-progress gaps between `.running`, `.slow`, and `.stalled`.
 ///
 /// Values here are first-pass defaults intended to be tuned later
 /// against real inter-event-gap and per-tool-duration distributions.
 /// The struct is fully `Sendable` + `Equatable` so future tuning is a
 /// trivial constants update with no behavioral churn.
 struct StallThresholds: Sendable, Equatable {
-  /// A gap (inter-event or per-tool) reaching this length promotes to
+  /// A gap (inter-event or per-tool no-progress) reaching this length promotes to
   /// `.slow`. The UI surfaces a "still working…" annotation.
   let slowGapMs: Int
 

desktop/macos/Desktop/Sources/CloudConnectorGuidanceOverlay.swift

@@ -223,7 +223,7 @@ final class CloudConnectorGuidanceOverlay {
     settingsWatchTask?.cancel()
     window?.close()
 
-    let cardSize = CGSize(width: 180, height: 164)
+    let cardSize = Self.dragCardSize(appName: appName)
     dragCardSize = cardSize
     let dragTargetState = ScreenRecordingDragTargetState(frame: anchor)
     self.dragTargetState = dragTargetState
@@ -324,6 +324,14 @@ final class CloudConnectorGuidanceOverlay {
     return SpatialOverlayGeometry.clamped(proposed, to: visibleFrame, padding: 12)
   }
 
+  /// A named development bundle can have a much longer display name than the
+  /// production app. Widen the helper rather than allowing its instruction to
+  /// render outside the transparent panel and get clipped by AppKit.
+  static func dragCardSize(appName: String) -> CGSize {
+    let hasLongDisplayName = appName.count > 16
+    return CGSize(width: hasLongDisplayName ? 240 : 180, height: hasLongDisplayName ? 180 : 164)
+  }
+
   static func dragCardInitialAlpha(reduceMotion: Bool) -> CGFloat {
     reduceMotion ? 1 : 0
   }
@@ -822,7 +830,8 @@ private struct ScreenRecordingDragCardView: View {
           .foregroundColor(OmiColors.textPrimary)
           .multilineTextAlignment(.center)
           .lineSpacing(-1)
-          .fixedSize(horizontal: true, vertical: true)
+          .fixedSize(horizontal: false, vertical: true)
+          .frame(maxWidth: size.width - 20)
           .shadow(color: Color.black.opacity(0.65), radius: 3, y: 1)
       }
     }

desktop/macos/Desktop/Sources/FloatingControlBar/AIResponseView.swift

@@ -54,6 +54,9 @@ struct AIResponseView: View {
         currentContentView
       }
       .frame(maxWidth: .infinity, maxHeight: .infinity)
+      .overlay(alignment: .bottom) {
+        ChatComposerFade()
+      }
 
       if let shareFeedbackMessage, showShareFeedback {
         shareFeedbackBanner
@@ -204,6 +207,7 @@ struct AIResponseView: View {
         case .toolCalls(_, let calls):
           ToolCallsGroup(
             calls: calls,
+            compact: true,
             onOpenAgent: onOpenAgent,
             onOpenAgentRef: onOpenAgentRef
           )
@@ -448,35 +452,38 @@ struct AIResponseView: View {
         .environment(\.colorScheme, .dark)
       }
 
-      HStack(spacing: OmiSpacing.xs) {
-        Button(action: { shareLink() }) {
-          Image(systemName: showShareFeedback ? "checkmark" : "arrowshape.turn.up.right")
+      VStack(spacing: 0) {
+        HStack(spacing: OmiSpacing.xs) {
+          Button(action: { shareLink() }) {
+            Image(systemName: showShareFeedback ? "checkmark" : "arrowshape.turn.up.right")
+              .scaledFont(size: OmiType.body)
+              .foregroundColor(showShareFeedback ? .green : .secondary)
+          }
+          .buttonStyle(.plain)
+          .help("Copy share link")
+          .disabled(isSharingLink)
+
+          TextField("Ask follow up...", text: $followUpText)
+            .textFieldStyle(.plain)
             .scaledFont(size: OmiType.body)
-            .foregroundColor(showShareFeedback ? .green : .secondary)
-        }
-        .buttonStyle(.plain)
-        .help("Copy share link")
-        .disabled(isSharingLink)
+            .padding(.horizontal, OmiSpacing.sm)
+            .padding(.vertical, OmiSpacing.xs)
+            .background(Color.white.opacity(isDropTargeted ? 0.18 : 0.10))
+            .cornerRadius(OmiChrome.elementRadius)
+            .focused($isFollowUpFocused)
+            .onSubmit {
+              sendFollowUp()
+            }
 
-        TextField("Ask follow up...", text: $followUpText)
-          .textFieldStyle(.plain)
-          .scaledFont(size: OmiType.body)
-          .padding(.horizontal, OmiSpacing.sm)
-          .padding(.vertical, OmiSpacing.xs)
-          .background(Color.white.opacity(isDropTargeted ? 0.18 : 0.10))
-          .cornerRadius(OmiChrome.elementRadius)
-          .focused($isFollowUpFocused)
-          .onSubmit {
-            sendFollowUp()
+          Button(action: { sendFollowUp() }) {
+            Image(systemName: "arrow.up.circle.fill")
+              .scaledFont(size: OmiType.heading)
+              .foregroundColor(canSendFollowUp ? .white : .secondary)
           }
-
-        Button(action: { sendFollowUp() }) {
-          Image(systemName: "arrow.up.circle.fill")
-            .scaledFont(size: OmiType.heading)
-            .foregroundColor(canSendFollowUp ? .white : .secondary)
+          .disabled(!canSendFollowUp)
+          .buttonStyle(.plain)
         }
-        .disabled(!canSendFollowUp)
-        .buttonStyle(.plain)
+        .chatComposerShell(fill: OmiColors.backgroundSecondary.opacity(0.82))
       }
     }
     .onDrop(of: [UTType.fileURL], isTargeted: $isDropTargeted, perform: handleAttachmentDrop)

desktop/macos/Desktop/Sources/FloatingControlBar/FloatingControlBarWindow.swift

@@ -779,15 +779,15 @@ class FloatingControlBarWindow: NSPanel, NSWindowDelegate {
     observePttHint()
   }
 
-  private func performSpacesTransitionGrowIn() {
+  // Internal so the regression test can exercise the same workspace-transition
+  // path that the NSWorkspace observer invokes.
+  func performSpacesTransitionGrowIn() {
     updateNotchIslandState()
     guard notchModeEnabled, isVisible else { return }
-    // The panel already lives on every Space (.canJoinAllSpaces), so switching
-    // Spaces must NOT replay the reveal "pop" — doing so re-zoomed the island on
-    // every desktop/app switch, which felt excessive. Keep it fully revealed and
-    // only re-assert the resting frame if the current one has actually drifted
-    // (e.g. the active screen's notch geometry changed).
+    // Do not replay the reveal "pop" on Space changes; preserve chat size while
+    // non-chat surfaces recover their canonical frame from this callback.
     state.notchRevealProgress = 1
+    guard !state.showingAIConversation else { return }
     let targetFrame = defaultFrameForCurrentState()
     guard !Self.framesEquivalent(frame, targetFrame) else { return }
     resizeToFrame(targetFrame, makeResizable: styleMask.contains(.resizable), animated: false)