arul28 · Jun 13, 2026 · Jun 13, 2026 · Jun 13, 2026 · Jun 13, 2026 · Jun 13, 2026
@@ -0,0 +1,51 @@
+/* @vitest-environment jsdom */
+
+import React from "react";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useAppStore } from "../../state/appStore";
+import { WorktreesCard } from "./WorktreesCard";
+
+describe("WorktreesCard", () => {
+  const originalAde = window.ade;
+  const originalRefreshLanes = useAppStore.getState().refreshLanes;
+  let refreshLanes: typeof originalRefreshLanes;
+
+  beforeEach(() => {
+    refreshLanes = vi.fn(async () => undefined) as unknown as typeof originalRefreshLanes;
+    useAppStore.setState({ refreshLanes });
+    window.ade = ({
+      ...(originalAde ?? {}),
+      lanes: {
+        ...((originalAde as typeof window.ade | undefined)?.lanes ?? {}),
+        listUnregisteredWorktrees: vi.fn()
+          .mockResolvedValueOnce([{ path: "/repo/worktree-a", branch: "feature/a" }])
+          .mockResolvedValueOnce([]),
+        attach: vi.fn(async () => ({})),
+      },
+    } as unknown) as typeof window.ade;
+  });
+
+  afterEach(() => {
+    cleanup();
+    window.ade = originalAde;
+    useAppStore.setState({ refreshLanes: originalRefreshLanes });
+    vi.restoreAllMocks();
+  });
+
+  it("refreshes the shared lane store after importing existing worktrees", async () => {
+    render(<WorktreesCard />);
+
+    await screen.findByText("feature/a");
+    fireEvent.click(screen.getByRole("button", { name: "Add 1 as lane" }));
+
+    await waitFor(() => {
+      expect(window.ade.lanes.attach).toHaveBeenCalledWith({
+        name: "feature/a",
+        attachedPath: "/repo/worktree-a",
+      });
+      expect(refreshLanes).toHaveBeenCalledWith({ includeStatus: false });
+      expect(window.ade.lanes.listUnregisteredWorktrees).toHaveBeenCalledTimes(2);
+    });
+  });
+});
@@ -1,6 +1,7 @@
 import React, { useCallback, useEffect, useRef, useState } from "react";
 import { CircleNotch, GitFork, WarningCircle, Check } from "@phosphor-icons/react";
 import type { UnregisteredLaneCandidate } from "../../../shared/types/lanes";
+import { useAppStore } from "../../state/appStore";
 import { COLORS, SANS_FONT, MONO_FONT } from "../lanes/laneDesignTokens";
 import { Button } from "../ui/Button";
 import { RescanButton } from "./RescanButton";
@@ -9,6 +10,7 @@ import { CARD_BASE, SECTION_LABEL } from "./onboardingTheme";
 type LoadOptions = { preselectAll?: boolean; keepSelected?: Set<string> };
 
 export function WorktreesCard() {
+  const refreshLanes = useAppStore((s) => s.refreshLanes);
   const [worktrees, setWorktrees] = useState<UnregisteredLaneCandidate[]>([]);
   const [loading, setLoading] = useState(true);
   const [fetchError, setFetchError] = useState<string | null>(null);
@@ -85,6 +87,15 @@ export function WorktreesCard() {
         );
       }
     }
+    if (ok > 0) {
+      try {
+        await refreshLanes({ includeStatus: false });
+      } catch (err) {
+        collectedErrors.push(
+          `Added ${ok} worktree${ok !== 1 ? "s" : ""}, but the lane list did not refresh: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
     setErrors(collectedErrors);
     setImportedCount((c) => c + ok);
     setAttaching(false);

@@ -129,6 +129,17 @@ func isRemoteCommandApplicationError(_ error: Error) -> Bool {
     && nsError.userInfo["ADEErrorCode"] != nil
 }
 
+func isSyncRequestTimeoutError(_ error: Error) -> Bool {
+  let nsError = error as NSError
+  return nsError.domain == "ADE" && nsError.code == 23
+}
+
+func syncShouldQueueCommandAfterSendFailure(error: Error, canSendLiveRequests: Bool, queueable: Bool) -> Bool {
+  guard queueable else { return false }
+  guard !isRemoteCommandApplicationError(error) else { return false }
+  return !canSendLiveRequests || isSyncRequestTimeoutError(error)
+}
+
 func decodeHydrationPayload<T: Decodable>(_ raw: Any, as type: T.Type, domainLabel: String, decoder: JSONDecoder) throws -> T {
   do {
     let data = try adeJSONData(withJSONObject: raw)
@@ -1305,6 +1316,7 @@ final class SyncService: ObservableObject {
   private var hydrationTask: Task<Void, Never>?
   private var reconnectTask: Task<Void, Never>?
   private var networkPathReconnectTask: Task<Void, Never>?
+  private var pendingOperationFlushTask: Task<Void, Never>?
   private var lanePresenceHeartbeatTask: Task<Void, Never>?
   private var openLaneReferenceCounts: [String: Int] = [:]
   private var terminalBufferRevisionTask: Task<Void, Never>?
@@ -2128,6 +2140,7 @@ final class SyncService: ObservableObject {
     projectSelectionTask?.cancel()
     reconnectTask?.cancel()
     networkPathReconnectTask?.cancel()
+    pendingOperationFlushTask?.cancel()
     lanePresenceHeartbeatTask?.cancel()
     terminalBufferRevisionTask?.cancel()
     chatEventRevisionTask?.cancel()
@@ -7771,6 +7784,8 @@ final class SyncService: ObservableObject {
     clientHeartbeatTask = nil
     hydrationTask?.cancel()
     hydrationTask = nil
+    pendingOperationFlushTask?.cancel()
+    pendingOperationFlushTask = nil
     lanePresenceHeartbeatTask?.cancel()
     lanePresenceHeartbeatTask = nil
     if let socket {
@@ -7959,6 +7974,23 @@ final class SyncService: ObservableObject {
     pendingOperationCount = operations.count
   }
 
+  private func schedulePendingOperationFlush(delayNanoseconds: UInt64 = 2_000_000_000) {
+    guard pendingOperationFlushTask == nil else { return }
+    pendingOperationFlushTask = Task { @MainActor [weak self] in
+      var nextDelay = delayNanoseconds
+      while !Task.isCancelled {
+        try? await Task.sleep(nanoseconds: nextDelay)
+        guard let self, !Task.isCancelled else { return }
+        let shouldRetry = await self.flushPendingOperations()
+        if !shouldRetry || !self.canSendLiveRequests() {
+          self.pendingOperationFlushTask = nil
+          return
+        }
+        nextDelay = 15_000_000_000
+      }
+    }
+  }
+
   private func enqueueOperation(kind: String, action: String, args: [String: Any], id: String? = nil) throws {
     guard JSONSerialization.isValidJSONObject(args) else {
       throw NSError(domain: "ADE", code: 11, userInfo: [NSLocalizedDescriptionKey: "Invalid queued operation payload."])
@@ -7976,6 +8008,9 @@ final class SyncService: ObservableObject {
       projectRootPath: activeProjectRootPath
     ))
     savePendingOperations(queued)
+    if canSendLiveRequests() {
+      schedulePendingOperationFlush()
+    }
   }
 
   private func pendingOperationMatchesActiveProject(_ operation: PendingOperation) -> Bool {
@@ -8009,21 +8044,33 @@ final class SyncService: ObservableObject {
     return dict
   }
 
-  private func flushPendingOperations() async {
-    guard canSendLiveRequests() else { return }
+  private func pendingOperationMatches(_ lhs: PendingOperation, _ rhs: PendingOperation) -> Bool {
+    lhs.id == rhs.id
+      && lhs.kind == rhs.kind
+      && lhs.action == rhs.action
+      && lhs.payload == rhs.payload
+  }
+
+  private func removePendingOperation(_ operation: PendingOperation) {
+    var queued = loadPendingOperations()
+    if let index = queued.firstIndex(where: { pendingOperationMatches($0, operation) }) {
+      queued.remove(at: index)
+      savePendingOperations(queued)
+    } else {
+      pendingOperationCount = queued.count
+    }
+  }
+
+  @discardableResult
+  private func flushPendingOperations() async -> Bool {
+    guard canSendLiveRequests() else { return false }
     var queued = loadPendingOperations()
     guard !queued.isEmpty else {
       pendingOperationCount = 0
-      return
+      return false
     }
 
-    var index = queued.startIndex
-    while index < queued.endIndex {
-      let operation = queued[index]
-      guard pendingOperationMatchesActiveProject(operation) else {
-        index = queued.index(after: index)
-        continue
-      }
+    while let operation = queued.first(where: pendingOperationMatchesActiveProject) {
       do {
         let args = try decodeQueuedArgs(operation)
         switch operation.kind {
@@ -8040,20 +8087,28 @@ final class SyncService: ObservableObject {
         default:
           throw NSError(domain: "ADE", code: 13, userInfo: [NSLocalizedDescriptionKey: "Unknown queued operation type."])
         }
-        queued.remove(at: index)
-        savePendingOperations(queued)
+        removePendingOperation(operation)
       } catch {
         lastError = SyncUserFacingError.message(for: error)
-        if canSendLiveRequests() {
-          queued.remove(at: index)
-          savePendingOperations(queued)
+        let stillLive = canSendLiveRequests()
+        if isRemoteCommandApplicationError(error) || (stillLive && !isSyncRequestTimeoutError(error)) {
+          removePendingOperation(operation)
+          queued = loadPendingOperations()
           continue
         }
-        savePendingOperations(queued)
-        connectionState = .error
-        break
+        if !stillLive {
+          connectionState = .error
+        }
+        if isSyncRequestTimeoutError(error) {
+          verifyTransportAliveAfterRequestTimeout(error as NSError)
+          return stillLive
+        }
+        return false
       }
+      queued = loadPendingOperations()
     }
+    pendingOperationCount = loadPendingOperations().count
+    return false
   }
 
   private func performCommandRequest(
@@ -8109,10 +8164,16 @@ final class SyncService: ObservableObject {
           timeoutNanoseconds: timeoutNanoseconds
         )
       } catch {
-        if !isRemoteCommandApplicationError(error),
-           !canSendLiveRequests(),
-           commandPolicy(for: action)?.queueable == true {
+        let stillLive = canSendLiveRequests()
+        if syncShouldQueueCommandAfterSendFailure(
+          error: error,
+          canSendLiveRequests: stillLive,
+          queueable: commandPolicy(for: action)?.queueable == true
+        ) {
           try enqueueOperation(kind: "command", action: action, args: args, id: commandId)
+          if stillLive, isSyncRequestTimeoutError(error) {
+            verifyTransportAliveAfterRequestTimeout(error as NSError)
+          }
           return ["queued": true]
         }
         throw error
@@ -8744,10 +8805,16 @@ extension SyncService {
       do {
         return try await performCommandRequest(action: action, args: args, commandId: commandId)
       } catch {
-        if !isRemoteCommandApplicationError(error),
-           !canSendLiveRequests(),
-           commandPolicy(for: action)?.queueable == true {
+        let stillLive = canSendLiveRequests()
+        if syncShouldQueueCommandAfterSendFailure(
+          error: error,
+          canSendLiveRequests: stillLive,
+          queueable: commandPolicy(for: action)?.queueable == true
+        ) {
           try enqueueOperation(kind: "command", action: action, args: args, id: commandId)
+          if stillLive, isSyncRequestTimeoutError(error) {
+            verifyTransportAliveAfterRequestTimeout(error as NSError)
+          }
           return ["queued": true]
         }
         throw error

@@ -10,6 +10,7 @@ extension WorkSessionDestinationView {
     let text = text.trimmingCharacters(in: .whitespacesAndNewlines)
     guard !text.isEmpty else { return false }
     guard canSendChatMessages else { return false }
+    copySubmittedWorkPromptToPasteboard(text)
 
     let initialDeliveryState = (sendWillQueueChatMessage || useSteer) ? "queued" : "sending"
     let echo = WorkLocalEchoMessage(
@@ -480,6 +481,13 @@ extension WorkSessionDestinationView {
     }
   }
 
+  @MainActor
+  func copySubmittedWorkPromptToPasteboard(_ text: String) {
+    let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard !trimmed.isEmpty else { return }
+    UIPasteboard.general.string = trimmed
+  }
+
   func presentCreateLanePr() {
     createPrPresented = true
   }

@@ -824,6 +824,7 @@ struct WorkSessionDestinationView: View {
       handledOpeningPromptKey = promptKey
       return
     }
+    copySubmittedWorkPromptToPasteboard(prompt)
     handledOpeningPromptKey = promptKey
 
     let echo: WorkLocalEchoMessage

@@ -693,6 +693,47 @@ final class ADETests: XCTestCase {
     )
   }
 
+  func testCommandSendFailureQueuePolicyPreservesQueueableTimeoutsOnly() {
+    XCTAssertTrue(
+      syncShouldQueueCommandAfterSendFailure(
+        error: SyncRequestTimeout.error(),
+        canSendLiveRequests: true,
+        queueable: true
+      )
+    )
+    XCTAssertTrue(
+      syncShouldQueueCommandAfterSendFailure(
+        error: NSError(domain: NSURLErrorDomain, code: NSURLErrorTimedOut),
+        canSendLiveRequests: false,
+        queueable: true
+      )
+    )
+
+    let error = NSError(
+      domain: "ADE",
+      code: 17,
+      userInfo: [
+        NSLocalizedDescriptionKey: "Remote command failed.",
+        "ADEErrorCode": "command_failed",
+      ]
+    )
+
+    XCTAssertFalse(
+      syncShouldQueueCommandAfterSendFailure(
+        error: error,
+        canSendLiveRequests: false,
+        queueable: true
+      )
+    )
+    XCTAssertFalse(
+      syncShouldQueueCommandAfterSendFailure(
+        error: SyncRequestTimeout.error(),
+        canSendLiveRequests: true,
+        queueable: false
+      )
+    )
+  }
+
   func testSyncConnectionHealthTreatsSyncingAsConnectedTransport() {
     let health = syncConnectionHealth(
       connectionState: .syncing,

@@ -98,6 +98,9 @@ Renderer — onboarding:
 - `apps/desktop/src/renderer/components/onboarding/GitHubCard.tsx`,
   `LinearCard.tsx`, `WorktreesCard.tsx` — setup cards for repository auth,
   Linear OAuth / API-key auth, and importing existing worktrees as lanes.
+  `WorktreesCard` refreshes the shared lane store after successful imports so
+  the first post-onboarding Work/Lanes views render the attached lanes without
+  waiting for a later project refresh.
 - `apps/desktop/src/renderer/components/onboarding/InputPopover.tsx`,
   `RescanButton.tsx`, `onboardingTheme.ts` — shared setup-card controls and
   brand/status styling tokens.

@@ -752,8 +752,9 @@ project scope split.
   rows, plus rows for tables that no longer exist locally, before
   opening the apply transaction. A batch that contains only ignored
   tables is a no-op and preserves the local database version.
-- **Controller command queues replay on reconnect.** If the runtime
-  advertises `chat.send` as queueable and the user sends while the
-  desktop is reconnecting, the iOS app stores the command locally with
-  a queued delivery state and replays on reconnect. Do not assume
-  synchronous semantics from the phone side.
+- **Controller command queues replay on reconnect and on live-send
+  timeouts.** If the runtime advertises `chat.send` as queueable and the user
+  sends while the desktop is reconnecting, or the send request times out while
+  the socket still appears connected, the iOS app stores the command locally
+  with a queued delivery state and replays it with the same `commandId`. Do not
+  assume synchronous semantics from the phone side.