Mobile + desktop enhancements (#216)

* ship: prepare lane for review

Mobile + desktop enhancements:
- iOS: PR Draft filter, work session/chat refinements, sync reduced-load support
- Desktop: iOS sim attachToChatSession, sync host backpressure, clipboard image paste fallback, terminal WebGL renderer reset, work-log status resolver, chat composer iOS-sim toggle
- Tests: clipboard-paste contract test, iOS sync reduced-load coverage

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* ship: iteration 1 — fix test-desktop (1), address 13 CodeRabbit comments

CI fix:
- AgentChatPane.tsx: guard iosSimulator IPC with try/catch + optional chaining (sync TypeError aborted createSession in tests where the iosSimulator namespace is unmocked)

Review fixes (CodeRabbit):
- iosSimulatorService: attachToChatSession validates owner on null detach
- registerIpc: guard null/non-object payload in attach handler
- syncHostService: centralize backpressure check in send()
- AgentChatComposer: clipboard fallback claims generation before attaching to prevent double-attach
- AgentChatMessageList: chip parser requires valid token boundary
- AgentChatPane: gate eager-create attach behind iosSimulatorOpen
- ChatWorkLogBlock: trim() check on entry.output
- TerminalView: pendingWebGLRestore flag survives renderer changes
- SyncService.swift: monotonic clock for PendingRequest.startedAt + forceReducedSyncLoadUntil + RTT
- SyncService.swift: teardownSocket before markConnectionLoadStrained re-subscribe
- WorkRootScreen+Actions: priority-sort lanes before reduced-mode prefix(6)
- WorkSessionDestinationView: combine isLive && hostReachable; preserve fallbackEntries on skip/fail

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: arul28

apps/desktop/src/main/services/ios/iosSimulatorService.ts

@@ -2549,6 +2549,27 @@ export function createIosSimulatorService(args: CreateIosSimulatorServiceArgs) {
     });
   };
 
+  const attachToChatSession = (chatSessionId: string | null, callerChatSessionId: string | null = chatSessionId): IosSimulatorSession | null => {
+    if (!activeSession) return null;
+    // Ownership check applies symmetrically: callers passing null to detach
+    // must still be the current owner, otherwise an unrelated chat could free
+    // another chat's simulator binding. The caller's own chat id is supplied
+    // via callerChatSessionId; for attach calls it is the same as the new
+    // chatSessionId, for detach calls (chatSessionId === null) it identifies
+    // the chat requesting the detach.
+    if (
+      activeSession.chatSessionId
+      && callerChatSessionId
+      && activeSession.chatSessionId !== callerChatSessionId
+    ) {
+      throw new IosSimulatorOwnedBySessionError(activeSession);
+    }
+    if (activeSession.chatSessionId === chatSessionId) return activeSession;
+    activeSession = { ...activeSession, chatSessionId };
+    emit({ type: "session-updated", session: activeSession });
+    return activeSession;
+  };
+
   const launch = async (launchArgs: IosSimulatorLaunchArgs = {}): Promise<IosSimulatorSession> => {
     if (process.platform !== "darwin") {
       throw new Error("iOS Simulator control is only available on macOS.");
@@ -2604,10 +2625,21 @@ export function createIosSimulatorService(args: CreateIosSimulatorServiceArgs) {
 
       currentStep = "open-simulator";
       emitLaunchProgress(launchId, "open-simulator", "running", "Preparing Simulator.app in the background...", null, { deviceUdid: device.udid });
-      const openArgs = launchArgs.keepSimulatorInBackground === false
-        ? ["-a", "Simulator"]
-        : ["-g", "-a", "Simulator"];
+      const keepInBackground = launchArgs.keepSimulatorInBackground !== false;
+      const openArgs = keepInBackground
+        ? ["-gj", "-a", "Simulator"]
+        : ["-a", "Simulator"];
       spawn("open", openArgs, { detached: true, stdio: "ignore" }).unref();
+      if (keepInBackground) {
+        // `simctl boot`/`launch` can still steal focus on some macOS versions even
+        // with `open -gj`. Force-hide Simulator.app via System Events so the user
+        // never sees it pop in front of ADE during the launch sequence.
+        spawn(
+          "osascript",
+          ["-e", 'tell application "System Events" to if exists process "Simulator" then set visible of process "Simulator" to false'],
+          { detached: true, stdio: "ignore" },
+        ).unref();
+      }
       emitLaunchProgress(launchId, "open-simulator", "complete", "Simulator.app is ready in the background.", null, { deviceUdid: device.udid });
 
       currentStep = "resolve-target";
@@ -2683,6 +2715,15 @@ export function createIosSimulatorService(args: CreateIosSimulatorServiceArgs) {
         env: childEnv,
         timeoutMs: 60_000,
       });
+      if (launchArgs.keepSimulatorInBackground !== false) {
+        // simctl launch frequently activates Simulator.app — re-hide it so ADE
+        // stays in front for the remainder of the session.
+        spawn(
+          "osascript",
+          ["-e", 'tell application "System Events" to if exists process "Simulator" then set visible of process "Simulator" to false'],
+          { detached: true, stdio: "ignore" },
+        ).unref();
+      }
       emitLaunchProgress(launchId, "launch-app", "complete", "App launched.", bundleId, { deviceUdid: device.udid, targetId: target.target.id });
       emitLaunchProgress(launchId, "ready", "complete", "iOS simulator drawer is ready.", device.name, { deviceUdid: device.udid, targetId: target.target.id });
       emit({ type: "session-started", session });
@@ -3375,6 +3416,7 @@ export function createIosSimulatorService(args: CreateIosSimulatorServiceArgs) {
     listDevices,
     listLaunchTargets,
     launch,
+    attachToChatSession,
     shutdown,
     screenshot,
     getScreenSnapshot,

apps/desktop/src/main/services/ipc/registerIpc.ts

@@ -2112,6 +2112,22 @@ export function registerIpc({
     clipboard.writeText(text);
   });
 
+  ipcMain.handle(IPC.appReadClipboardImage, async (): Promise<{ data: string; filename: string; mimeType: string } | null> => {
+    const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+    const image = clipboard.readImage();
+    if (image.isEmpty()) return null;
+    const png = image.toPNG();
+    if (!png.byteLength) return null;
+    if (png.byteLength > MAX_ATTACHMENT_BYTES) {
+      throw new Error("Clipboard image must be 10 MB or smaller.");
+    }
+    return {
+      data: png.toString("base64"),
+      filename: "clipboard.png",
+      mimeType: "image/png",
+    };
+  });
+
   ipcMain.handle(IPC.appGetImageDataUrl, async (_event, arg: { path: string }): Promise<{ dataUrl: string }> => {
     const filePath = resolveAllowedRendererPath(arg?.path);
     // Use async fs APIs and a size pre-check so a 10 MB image read never
@@ -5043,6 +5059,18 @@ export function registerIpc({
 
   ipcMain.handle(IPC.iosSimulatorLaunch, async (_event, arg = {}) => ensureIosSimulator().launch(arg));
 
+  ipcMain.handle(IPC.iosSimulatorAttachToChatSession, async (_event, arg) => {
+    // Tolerate null/undefined payloads (treated as detach) and reject malformed
+    // shapes with a clear error rather than throwing on a property dereference.
+    if (arg !== undefined && arg !== null && typeof arg !== "object") {
+      throw new Error("iosSimulatorAttachToChatSession requires { chatSessionId } payload.");
+    }
+    const payload = (arg ?? {}) as { chatSessionId?: string | null; callerChatSessionId?: string | null };
+    const chatSessionId = payload.chatSessionId ?? null;
+    const callerChatSessionId = payload.callerChatSessionId ?? chatSessionId;
+    return ensureIosSimulator().attachToChatSession(chatSessionId, callerChatSessionId);
+  });
+
   ipcMain.handle(IPC.iosSimulatorShutdown, async (_event, arg = {}) => ensureIosSimulator().shutdown(arg));
 
   ipcMain.handle(IPC.iosSimulatorScreenshot, async (_event, arg = {}) => ensureIosSimulator().screenshot(arg));

apps/desktop/src/main/services/sync/syncHostService.ts

@@ -100,6 +100,7 @@ const DEFAULT_SYNC_HEARTBEAT_INTERVAL_MS = 30_000;
 const DEFAULT_SYNC_POLL_INTERVAL_MS = 400;
 const DEFAULT_BRAIN_STATUS_INTERVAL_MS = 5_000;
 const DEFAULT_TERMINAL_SNAPSHOT_BYTES = 220_000;
+const PEER_BACKPRESSURE_BYTES = 4 * 1024 * 1024;
 const LANE_PRESENCE_TTL_MS = 60_000;
 const SYNC_MDNS_SERVICE_TYPE = "ade-sync";
 export const SYNC_TAILNET_DISCOVERY_SERVICE_NAME = "svc:ade-sync";
@@ -753,6 +754,13 @@ export function createSyncHostService(args: SyncHostServiceArgs) {
     const sentAt = nowIso();
     for (const peer of peers) {
       if (!peer.authenticated || peer.ws.readyState !== WebSocket.OPEN) continue;
+      if (isPeerBackpressured(peer)) {
+        args.logger.debug("sync_host.heartbeat_deferred_backpressure", {
+          peerDeviceId: peer.metadata?.deviceId ?? null,
+          bufferedAmount: peer.ws.bufferedAmount,
+        });
+        continue;
+      }
       if (peer.awaitingHeartbeatAt) {
         peer.missedHeartbeatCount += 1;
         if (peer.missedHeartbeatCount >= 2) {
@@ -1095,10 +1103,23 @@ export function createSyncHostService(args: SyncHostServiceArgs) {
     }
   };
 
-  function send<TPayload>(ws: WebSocket, type: SyncEnvelope["type"], payload: TPayload, requestId?: string | null): void {
+  function send<TPayload>(target: WebSocket | PeerState, type: SyncEnvelope["type"], payload: TPayload, requestId?: string | null): void {
+    const ws = target instanceof WebSocket ? target : target.ws;
+    if (ws.readyState !== WebSocket.OPEN) return;
+    // Drop sends to backpressured peers as the default — most envelopes are
+    // either replayable (chat events / changesets re-derived from db state) or
+    // tolerable to lose (acks, status pings). Routes that *must* deliver under
+    // backpressure should call ws.send / sendAndWait directly.
+    if (target instanceof WebSocket ? ws.bufferedAmount >= PEER_BACKPRESSURE_BYTES : isPeerBackpressured(target)) {
+      return;
+    }
     ws.send(encodeSyncEnvelope({ type, payload, requestId, compressionThresholdBytes }));
   }
 
+  function isPeerBackpressured(peer: PeerState): boolean {
+    return peer.ws.bufferedAmount >= PEER_BACKPRESSURE_BYTES;
+  }
+
   function sendAndWait<TPayload>(
     ws: WebSocket,
     type: SyncEnvelope["type"],
@@ -1421,6 +1442,7 @@ export function createSyncHostService(args: SyncHostServiceArgs) {
 
     for (const peer of peers) {
       if (!peer.authenticated || peer.ws.readyState !== WebSocket.OPEN) continue;
+      if (isPeerBackpressured(peer)) continue;
       for (const sessionId of peer.subscribedChatSessionIds) {
         const session = args.sessionService.get(sessionId);
         if (!session?.transcriptPath) continue;
@@ -1441,6 +1463,7 @@ export function createSyncHostService(args: SyncHostServiceArgs) {
   function broadcastChatEvent(event: AgentChatEventEnvelope): void {
     for (const peer of peers) {
       if (!peer.authenticated || peer.ws.readyState !== WebSocket.OPEN) continue;
+      if (isPeerBackpressured(peer)) continue;
       if (!peer.subscribedChatSessionIds.has(event.sessionId)) continue;
       if (!rememberChatEventSent(peer, event)) continue;
       send(peer.ws, "chat_event", event);
@@ -1452,6 +1475,7 @@ export function createSyncHostService(args: SyncHostServiceArgs) {
     const currentDbVersion = args.db.sync.getDbVersion();
     for (const peer of peers) {
       if (!peer.authenticated || !peer.metadata || peer.ws.readyState !== WebSocket.OPEN) continue;
+      if (isPeerBackpressured(peer)) continue;
       if (currentDbVersion <= peer.lastKnownServerDbVersion) continue;
       const changes = args.db.sync
         .exportChangesSince(peer.lastKnownServerDbVersion)
@@ -2394,6 +2418,7 @@ export function createSyncHostService(args: SyncHostServiceArgs) {
       };
       for (const peer of peers) {
         if (!peer.authenticated || !peer.subscribedSessionIds.has(event.sessionId) || peer.ws.readyState !== WebSocket.OPEN) continue;
+        if (isPeerBackpressured(peer)) continue;
         send(peer.ws, "terminal_data", payload);
       }
     },
@@ -2407,6 +2432,7 @@ export function createSyncHostService(args: SyncHostServiceArgs) {
       };
       for (const peer of peers) {
         if (!peer.authenticated || !peer.subscribedSessionIds.has(event.sessionId) || peer.ws.readyState !== WebSocket.OPEN) continue;
+        if (isPeerBackpressured(peer)) continue;
         send(peer.ws, "terminal_exit", payload);
       }
     },

apps/desktop/src/preload/global.d.ts

@@ -642,6 +642,7 @@ declare global {
         revealPath: (path: string) => Promise<void>;
         openPath: (path: string) => Promise<void>;
         writeClipboardText: (text: string) => Promise<void>;
+        readClipboardImage: () => Promise<{ data: string; filename: string; mimeType: string } | null>;
         getImageDataUrl: (path: string) => Promise<{ dataUrl: string }>;
         writeClipboardImage: (path: string) => Promise<void>;
         openPathInEditor: (args: {
@@ -1265,6 +1266,7 @@ declare global {
         listDevices: () => Promise<IosSimulatorDevice[]>;
         listLaunchTargets: (args?: IosSimulatorListLaunchTargetsArgs) => Promise<IosSimulatorLaunchTarget[]>;
         launch: (args?: IosSimulatorLaunchArgs) => Promise<IosSimulatorSession>;
+        attachToChatSession: (args: { chatSessionId: string | null; callerChatSessionId?: string | null }) => Promise<IosSimulatorSession | null>;
         shutdown: (args?: IosSimulatorShutdownArgs) => Promise<IosSimulatorShutdownResult>;
         screenshot: (args?: { deviceUdid?: string | null }) => Promise<IosSimulatorScreenshot>;
         getScreenSnapshot: (args?: IosScreenSnapshotArgs) => Promise<IosScreenSnapshot>;

apps/desktop/src/preload/preload.ts

@@ -653,6 +653,8 @@ contextBridge.exposeInMainWorld("ade", {
       ipcRenderer.invoke(IPC.appOpenPath, { path }),
     writeClipboardText: async (text: string): Promise<void> =>
       ipcRenderer.invoke(IPC.appWriteClipboardText, { text }),
+    readClipboardImage: async (): Promise<{ data: string; filename: string; mimeType: string } | null> =>
+      ipcRenderer.invoke(IPC.appReadClipboardImage),
     getImageDataUrl: async (path: string): Promise<{ dataUrl: string }> =>
       ipcRenderer.invoke(IPC.appGetImageDataUrl, { path }),
     writeClipboardImage: async (path: string): Promise<void> =>
@@ -1798,6 +1800,8 @@ contextBridge.exposeInMainWorld("ade", {
       ipcRenderer.invoke(IPC.iosSimulatorListLaunchTargets, args),
     launch: async (args: IosSimulatorLaunchArgs = {}): Promise<IosSimulatorSession> =>
       ipcRenderer.invoke(IPC.iosSimulatorLaunch, args),
+    attachToChatSession: async (args: { chatSessionId: string | null; callerChatSessionId?: string | null }): Promise<IosSimulatorSession | null> =>
+      ipcRenderer.invoke(IPC.iosSimulatorAttachToChatSession, args),
     shutdown: async (args: IosSimulatorShutdownArgs = {}): Promise<IosSimulatorShutdownResult> =>
       ipcRenderer.invoke(IPC.iosSimulatorShutdown, args),
     screenshot: async (args: { deviceUdid?: string | null } = {}): Promise<IosSimulatorScreenshot> =>

apps/desktop/src/renderer/browserMock.ts

@@ -2638,6 +2638,7 @@ if (typeof window !== "undefined" && shouldInstallBrowserMock(window)) {
       openExternal: resolvedArg(undefined),
       revealPath: resolvedArg(undefined),
       writeClipboardText: resolvedArg(undefined),
+      readClipboardImage: resolved(null),
       getImageDataUrl: resolvedArg({ dataUrl: "" }),
       writeClipboardImage: resolvedArg(undefined),
       openPath: resolvedArg(undefined),

apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx

@@ -1,7 +1,7 @@
 /* @vitest-environment jsdom */
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { cleanup, fireEvent, render, screen, type RenderResult } from "@testing-library/react";
+import { cleanup, fireEvent, render, screen, waitFor, type RenderResult } from "@testing-library/react";
 import type { ComponentProps } from "react";
 import { AgentChatComposer } from "./AgentChatComposer";
 
@@ -63,7 +63,10 @@ beforeEach(() => {
   installMatchMediaMock();
 });
 
-afterEach(cleanup);
+afterEach(() => {
+  cleanup();
+  delete (window as any).ade;
+});
 
 function buildComposerProps(overrides: Partial<ComponentProps<typeof AgentChatComposer>> = {}) {
   const props: ComponentProps<typeof AgentChatComposer> = {
@@ -478,6 +481,51 @@ describe("AgentChatComposer", () => {
     expect((screen.getByLabelText("Upload file from disk") as HTMLButtonElement).disabled).toBe(false);
   });
 
+  it("attaches a native clipboard image when macOS Cmd+V does not expose paste files", async () => {
+    const originalPlatform = navigator.platform;
+    Object.defineProperty(navigator, "platform", {
+      configurable: true,
+      value: "MacIntel",
+    });
+    const readClipboardImage = vi.fn().mockResolvedValue({
+      data: "abc123",
+      filename: "clipboard.png",
+      mimeType: "image/png",
+    });
+    const saveTempAttachment = vi.fn().mockResolvedValue({ path: "/tmp/ade-clipboard.png" });
+    (window as any).ade = {
+      app: { readClipboardImage },
+      agentChat: { saveTempAttachment },
+    };
+
+    try {
+      const props = renderComposer({
+        turnActive: false,
+        draft: "",
+      });
+
+      fireEvent.keyDown(screen.getByPlaceholderText("Type to vibecode..."), {
+        key: "v",
+        metaKey: true,
+      });
+
+      await waitFor(() => expect(readClipboardImage).toHaveBeenCalledTimes(1));
+      expect(saveTempAttachment).toHaveBeenCalledWith({
+        data: "abc123",
+        filename: "clipboard.png",
+      });
+      expect(props.onAddAttachment).toHaveBeenCalledWith({
+        path: "/tmp/ade-clipboard.png",
+        type: "image",
+      });
+    } finally {
+      Object.defineProperty(navigator, "platform", {
+        configurable: true,
+        value: originalPlatform,
+      });
+    }
+  });
+
   it("hides native permission controls until a model is selected", () => {
     const props = buildComposerProps({
       modelId: "",