Add Copy & Delete to the context menu

Copies the item (or the selection, as plain lines) and removes it in one
step — the 'take this out' gesture. No shortcut: Cmd+X belongs to the text
fields, and a panel binding would steal it.

AGENTS.md

@@ -13,8 +13,10 @@ clicking an item copies it back to the clipboard.
   `NSStatusItem Preferred Position Prompt`). Left click toggles the panel,
   right click shows the menu (accessibility state, launch at login, open data
   folder, quit). Contains the single-instance guard and `LoginItem`
-  (`SMAppService`). The sync panel also carries a Launch at Login toggle (the
-  app's only settings surface). Also sets `NSApp.mainMenu` with Hide Panel (Cmd+W) and Quit
+  (`SMAppService`): the app auto-registers as a login item on the first
+  bundled launch (once, tracked by `loginItem.autoRegistered` in UserDefaults)
+  so it opens on startup by default; the Launch at Login toggle in the sync
+  panel (the app's only settings surface) is the opt-out. Also sets `NSApp.mainMenu` with Hide Panel (Cmd+W) and Quit
   (Cmd+Q) — an accessory app shows no menu bar, but the main menu still
   services key equivalents, which is the only way to quit from the keyboard
   while the panel has focus. `applicationShouldHandleReopen` shows the panel so
@@ -44,7 +46,12 @@ clicking an item copies it back to the clipboard.
   newline, Esc forwards to the panel (clear selection, else hide). Height is
   measured from the text and pushed into a `height` binding the panel applies
   as a frame — a representable cannot resize itself through
-  `intrinsicContentSize` once SwiftUI offers a larger size.
+  `intrinsicContentSize` once SwiftUI offers a larger size. The vertical
+  scroller is disabled until the text is taller than the max height, so it
+  never flashes during growth. The composer re-asserts first responder on
+  updates only while `canStealFocus` is true; the panel turns it off whenever
+  a modal field (search, edit, new workspace) or the sync overlay owns the
+  keyboard — otherwise every render stole focus back mid-edit.
 - `Sources/Prompt/PanelView.swift` — the panel UI. Header (workspace switcher,
   search, add photos), a segmented Workspace/All tab (All lists every prompt
   labeled with its workspace), item list, in-panel edit modal, composer.
@@ -53,8 +60,9 @@ clicking an item copies it back to the clipboard.
   switches sections. Click = select (Shift+click for a range); the selection
   bar offers Copy (single item), Copy as List, Copy as Lines and Delete;
   right-click = context menu acting on the whole selection (Copy, Copy as List,
-  Copy as Lines, Done, Edit, Open, Merge, Move To, Delete). Esc clears the
-  selection before it hides the panel. Drop target for images/files.
+  Copy as Lines, Copy & Delete, Done, Edit, Open, Merge, Move To, Delete). Esc clears the
+  selection before it hides the panel. Selection is scoped to the current view:
+  switching workspace, switching tab, or closing search clears it. Drop target for images/files.
 - `Sources/Prompt/PanelController.swift` — owns the floating `NSPanel`
   (`.nonactivatingPanel`, `.floating`, right-edge docked, frame autosaved as
   `PromptPanel`), and the Cmd+V paste monitor. Editing a note is an in-panel
@@ -177,6 +185,14 @@ brew upgrade --cask prompt
 
 ## Gotchas
 
+- **`@Published` publishes on every assignment, even when the value is
+  unchanged.** The 5-second sync poll used to assign `lastError = nil`
+  unconditionally; `PanelView` observes `SyncService`, so the entire panel
+  (rows, overlays, composer) rebuilt every 5 seconds, forever. Over five days
+  of uptime that was ~185 CPU-minutes and ~190 MB of footprint, and every
+  click started to lag. Poll state now goes through `setError`, which no-ops
+  when equal, and the header's sync dot is its own view so sync publishes
+  cannot invalidate the list.
 - **Never assign `NSApp.mainMenu`.** SwiftUI installs a menu whose Edit items
   are how AppKit routes Cmd+C/V/X/A/Z; replacing it with a hand-built menu
   silently breaks pasting, copying and select-all in the composer (this shipped
@@ -213,8 +229,23 @@ brew upgrade --cask prompt
   firing. The tap is re-enabled on `tapDisabledByTimeout`.
 - `Store` is `@MainActor`; anything reaching it from monitors/callbacks must
   go through `Task { @MainActor in }`.
+- **The composer steals focus via `updateNSView`, so gate it.** It used to
+  re-assert first responder on every render, which yanked focus out of the
+  edit dialog (and search/sync fields) on every keystroke. The gate is
+  `canStealFocus`; any new modal text field must be included in it.
+- **`doCommandBy` has no fall-through once the delegate implements it.**
+  Returning false for `insertNewline` on Shift+Return killed the event instead
+  of inserting a newline, so Shift+Return never actually worked. The composer
+  now inserts it explicitly, and reads the Shift state from the `keyDown`
+  currently being handled because `NSApp.currentEvent` is not reliably
+  populated when the command fires.
 - `captureSelection()` blocks up to 0.5s polling the pasteboard — keep it off
   the main thread (the hotkey handler already dispatches to a global queue).
+- **`SMAppService.mainApp.status` is `.notFound` for a bundle BTM has never
+  seen**, not `.notRegistered`, and `register()` still works from that state.
+  Only treat `.enabled` and `.requiresApproval` as "already done"; checking for
+  `.notRegistered` silently skips the registration. `Prompt --diag` prints the
+  raw status.
 - The double-Shift tap needs Accessibility; without it the event tap silently
   fails and only the Carbon fallbacks work. The panel banner and the status
   menu both surface the permission state, and `AppDelegate` shows a launch

Sources/Prompt/App.swift

@@ -61,6 +61,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
 
         setupStatusItem()
         promptForAccessibilityIfNeeded()
+        LoginItem.autoRegisterOnce()
 
         // Let SwiftUI finish installing its main menu, then augment it.
         DispatchQueue.main.async { self.installMenuItems() }
@@ -140,6 +141,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
     @MainActor
     private func writeDiagnostics() {
         var lines = ["Prompt diagnostics", "accessibility: \(AXIsProcessTrusted())"]
+        lines.append("login item status: \(SMAppService.mainApp.status.rawValue)")
         if let window = statusItem?.button?.window {
             lines.append("status item frame: \(window.frame)")
             if let screen = window.screen ?? NSScreen.main {
@@ -266,6 +268,31 @@ enum LoginItem {
         SMAppService.mainApp.status == .enabled
     }
 
+    /// Registers the app as a login item on first launch so Prompt opens on
+    /// startup without the user hunting for the toggle. Runs once (tracked in
+    /// UserDefaults) so a user who disables it is never overridden, and skips
+    /// `swift run`, where there is no bundle to register.
+    static func autoRegisterOnce() {
+        let key = "loginItem.autoRegistered"
+        guard Bundle.main.bundleIdentifier != nil,
+              !UserDefaults.standard.bool(forKey: key) else { return }
+        // A never-registered bundle reports `.notFound` on current macOS
+        // (BTM has no record), not `.notRegistered`, so only skip when there
+        // is nothing left to do.
+        switch SMAppService.mainApp.status {
+        case .enabled, .requiresApproval:
+            UserDefaults.standard.set(true, forKey: key)
+        default:
+            do {
+                try SMAppService.mainApp.register()
+                UserDefaults.standard.set(true, forKey: key)
+                NSLog("Prompt: registered as a login item (%d)", SMAppService.mainApp.status.rawValue)
+            } catch {
+                NSLog("Prompt: login item registration failed: %@", error.localizedDescription)
+            }
+        }
+    }
+
     static func toggle() -> Bool {
         let service = SMAppService.mainApp
         do {

Sources/Prompt/ComposerView.swift

@@ -16,6 +16,10 @@ struct ComposerView: NSViewRepresentable {
     @Binding var isFocused: Bool
     @Binding var height: CGFloat
     var placeholder: String
+    /// When false, the composer never makes itself first responder. The panel
+    /// turns this off while a modal field (search, edit, new workspace) or the
+    /// sync overlay is up — otherwise every render stole focus back here.
+    var canStealFocus: Bool = true
     var onSubmit: () -> Void
     var onEscape: (() -> Void)? = nil
 
@@ -34,7 +38,10 @@ struct ComposerView: NSViewRepresentable {
         let scrollView = NSScrollView()
         scrollView.drawsBackground = false
         scrollView.borderType = .noBorder
-        scrollView.hasVerticalScroller = true
+        // The scroller starts disabled and is only switched on once the text
+        // is taller than the max height. With it always on, every growth step
+        // briefly overflows and the scroller flashes for one frame.
+        scrollView.hasVerticalScroller = false
         scrollView.autohidesScrollers = true
         scrollView.horizontalScrollElasticity = .none
 
@@ -67,8 +74,10 @@ struct ComposerView: NSViewRepresentable {
             textView.string = text
             updateHeight(textView)
         }
-        textView.placeholderText = placeholder
-        if isFocused, scrollView.window?.firstResponder != textView {
+        if textView.placeholderText != placeholder {
+            textView.placeholderText = placeholder
+        }
+        if isFocused, canStealFocus, scrollView.window?.firstResponder != textView {
             scrollView.window?.makeFirstResponder(textView)
         }
     }
@@ -79,7 +88,9 @@ struct ComposerView: NSViewRepresentable {
         layoutManager.ensureLayout(for: textContainer)
         let content = layoutManager.usedRect(for: textContainer).height + 2 * textView.textContainerInset.height
         let line = Self.oneLineHeight
-        let clamped = max(line, min(content, line * maxLines + 1))
+        let maxHeight = line * maxLines + 1
+        textView.enclosingScrollView?.hasVerticalScroller = content > maxHeight
+        let clamped = max(line, min(content, maxHeight))
         if abs(height - clamped) > 0.5 {
             // Defer so the binding is not written from inside a layout pass.
             DispatchQueue.main.async { self.height = clamped }
@@ -101,7 +112,7 @@ struct ComposerView: NSViewRepresentable {
             ) { [weak self, weak textView] note in
                 guard let self, let textView,
                       (note.object as? NSWindow) === textView.window,
-                      self.parent.isFocused else { return }
+                      self.parent.isFocused, self.parent.canStealFocus else { return }
                 textView.window?.makeFirstResponder(textView)
             }
         }
@@ -129,8 +140,14 @@ struct ComposerView: NSViewRepresentable {
                 return true
             }
             guard commandSelector == #selector(NSResponder.insertNewline(_:)) else { return false }
-            if NSApp.currentEvent?.modifierFlags.contains(.shift) == true {
-                return false
+            // NSApp.currentEvent is not reliably set when the command fires,
+            // so the Shift state comes from the keyDown currently being handled.
+            // And returning false here does NOT fall through to the default
+            // newline insertion once a delegate implements doCommandBy — the
+            // event just dies — so insert the newline explicitly.
+            if (textView as? ComposerTextView)?.keyDownModifiers.contains(.shift) == true {
+                textView.insertNewline(nil)
+                return true
             }
             parent.onSubmit()
             return true
@@ -143,6 +160,16 @@ private final class ComposerTextView: NSTextView {
         didSet { needsDisplay = true }
     }
 
+    /// Modifier flags of the keyDown currently being handled. `doCommandBy`
+    /// runs inside that call tree and cannot rely on `NSApp.currentEvent`.
+    var keyDownModifiers: NSEvent.ModifierFlags = []
+
+    override func keyDown(with event: NSEvent) {
+        keyDownModifiers = event.modifierFlags
+        super.keyDown(with: event)
+        keyDownModifiers = []
+    }
+
     override func draw(_ dirtyRect: NSRect) {
         super.draw(dirtyRect)
         guard string.isEmpty, !placeholderText.isEmpty else { return }

Sources/Prompt/PanelView.swift

@@ -5,7 +5,6 @@ import UniformTypeIdentifiers
 struct PanelView: View {
     @ObservedObject var store: Store
     @ObservedObject private var sync = SyncService.shared
-
     @State private var composer = ""
     @State private var composerFocused = false
     @State private var composerHeight: CGFloat = ComposerView.oneLineHeight
@@ -20,13 +19,15 @@ struct PanelView: View {
     @State private var lastSelectedID: UUID?
     @State private var editingItem: PromptItem?
     @State private var editText = ""
+    @State private var editFocused = false
+    @State private var editHeight: CGFloat = ComposerView.oneLineHeight
     @State private var copiedID: UUID?
     @State private var accessibilityGranted = AXIsProcessTrusted()
 
     private enum Tab { case workspace, all }
     @State private var tab: Tab = .workspace
 
-    private enum Field: Hashable { case search, newWorkspace, editor }
+    private enum Field: Hashable { case search, newWorkspace }
     @FocusState private var focusedField: Field?
 
     var body: some View {
@@ -60,6 +61,11 @@ struct PanelView: View {
             accessibilityGranted = AXIsProcessTrusted()
         }
         .onAppear { composerFocused = true }
+        // Selection is scoped to the current view: switching workspace, tab,
+        // or leaving search clears it. Otherwise a selection made in one
+        // workspace kept acting (copy, delete) on items you can no longer see.
+        .onChange(of: store.activeSectionID) { clearSelection() }
+        .onChange(of: tab) { clearSelection() }
     }
 
     // MARK: - Header
@@ -84,8 +90,7 @@ struct PanelView: View {
             Spacer()
 
             Button { withAnimation(.easeInOut(duration: 0.15)) { showSync.toggle() } } label: {
-                Image(systemName: "arrow.triangle.2.circlepath")
-                    .foregroundStyle(sync.code == nil ? Color.secondary : Color.accentColor)
+                SyncDot()
             }
             .buttonStyle(.plain).help("Sync")
             Button { toggleSearch() } label: { Image(systemName: "magnifyingglass") }
@@ -143,6 +148,8 @@ struct PanelView: View {
                 .onExitCommand {
                     search = ""
                     showSearch = false
+                    focusedField = nil
+                    clearSelection()
                     composerFocused = true
                 }
             if !search.isEmpty {
@@ -317,6 +324,9 @@ struct PanelView: View {
                 store.copyAsLines(ids: ids)
                 flashCopied(item.id)
             }
+            Button(multiple ? "Copy & Delete \(ids.count) Items" : "Copy & Delete") {
+                copyAndDelete(item)
+            }
             Divider()
             Button(item.done ? "Mark as Not Done" : "Mark as Done") {
                 store.setDone(!item.done, ids: ids)
@@ -324,8 +334,9 @@ struct PanelView: View {
             if case .text(let text) = item.content, !multiple {
                 Button("Edit…") {
                     editText = text
+                    editHeight = ComposerView.oneLineHeight
                     editingItem = item
-                    focusedField = .editor
+                    editFocused = true
                 }
             }
             if case .image(let filename) = item.content, !multiple {
@@ -544,6 +555,9 @@ struct PanelView: View {
 
     // MARK: - Edit
 
+    /// The editor is a ComposerView too, so it behaves exactly like the main
+    /// input: Return saves, Shift+Return inserts a newline, Esc cancels, and
+    /// pasting goes through the same working path.
     @ViewBuilder
     private var editModal: some View {
         if let item = editingItem {
@@ -553,14 +567,18 @@ struct PanelView: View {
                 VStack(alignment: .leading, spacing: 12) {
                     Text("Edit")
                         .font(.headline)
-                    TextEditor(text: $editText)
-                        .font(.callout)
-                        .scrollContentBackground(.hidden)
-                        .frame(minHeight: 120, maxHeight: 280)
-                        .padding(8)
-                        .background(Theme.rowSwiftUI)
-                        .cornerRadius(8)
-                        .focused($focusedField, equals: .editor)
+                    ComposerView(
+                        text: $editText,
+                        isFocused: $editFocused,
+                        height: $editHeight,
+                        placeholder: "",
+                        onSubmit: { saveEdit(item) },
+                        onEscape: { dismissEditor() }
+                    )
+                    .frame(height: editHeight)
+                    .padding(8)
+                    .background(Theme.rowSwiftUI)
+                    .cornerRadius(8)
                     HStack {
                         Spacer()
                         Button("Cancel") { dismissEditor() }
@@ -595,11 +613,25 @@ struct PanelView: View {
     private func dismissEditor() {
         editingItem = nil
         editText = ""
+        editFocused = false
         composerFocused = true
     }
 
     // MARK: - New workspace
 
+    private var trimmedWorkspaceName: String {
+        newWorkspaceName.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    /// Case-insensitive, like the store's dedupe. The modal blocks creation
+    /// with a hint instead of silently switching to the existing workspace.
+    private var workspaceNameExists: Bool {
+        let name = trimmedWorkspaceName
+        return !name.isEmpty && store.sections.contains {
+            $0.name.caseInsensitiveCompare(name) == .orderedSame
+        }
+    }
+
     @ViewBuilder
     private var newWorkspaceModal: some View {
         if showNewWorkspace {
@@ -614,12 +646,17 @@ struct PanelView: View {
                         .focused($focusedField, equals: .newWorkspace)
                         .onSubmit(createWorkspace)
                         .onExitCommand { dismissNewWorkspace() }
+                    if workspaceNameExists {
+                        Text("A workspace named “\(trimmedWorkspaceName)” already exists.")
+                            .font(.caption)
+                            .foregroundStyle(.red)
+                    }
                     HStack {
                         Spacer()
                         Button("Cancel") { dismissNewWorkspace() }
                         Button("Create") { createWorkspace() }
                             .keyboardShortcut(.defaultAction)
-                            .disabled(newWorkspaceName.trimmingCharacters(in: .whitespaces).isEmpty)
+                            .disabled(trimmedWorkspaceName.isEmpty || workspaceNameExists)
                     }
                 }
                 .padding(16)
@@ -633,8 +670,8 @@ struct PanelView: View {
     }
 
     private func createWorkspace() {
-        let name = newWorkspaceName.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !name.isEmpty else { return }
+        let name = trimmedWorkspaceName
+        guard !name.isEmpty, !workspaceNameExists else { return }
         store.createSection(named: name)
         dismissNewWorkspace()
     }
@@ -642,6 +679,7 @@ struct PanelView: View {
     private func dismissNewWorkspace() {
         showNewWorkspace = false
         newWorkspaceName = ""
+        focusedField = nil
         composerFocused = true
     }
 
@@ -715,6 +753,9 @@ struct PanelView: View {
                 isFocused: $composerFocused,
                 height: $composerHeight,
                 placeholder: "Add a note or prompt (\(store.activeSection.name))",
+                // A modal field (search, edit, new workspace) or the sync
+                // overlay owns the keyboard; don't steal focus back mid-edit.
+                canStealFocus: focusedField == nil && !showSync && editingItem == nil,
                 onSubmit: submit,
                 onEscape: {
                     if selection.isEmpty {
@@ -817,6 +858,22 @@ struct PanelView: View {
         flashCopied(item.id)
     }
 
+    /// One gesture for "take this out": copy, then delete. A multi-selection
+    /// is copied as plain lines, same as Copy as Lines. No shortcut — Cmd+X
+    /// belongs to the composer/editor text fields, and a panel binding would
+    /// steal Cut from them.
+    private func copyAndDelete(_ item: PromptItem) {
+        let ids = effectiveIDs(for: item)
+        if ids.count > 1 {
+            store.copyAsLines(ids: ids)
+        } else {
+            store.copy(item)
+        }
+        store.delete(ids: ids)
+        selection.subtract(ids)
+        lastSelectedID = nil
+    }
+
     private func flashCopied(_ id: UUID) {
         withAnimation { copiedID = id }
         DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) {
@@ -837,6 +894,8 @@ struct PanelView: View {
             focusedField = .search
         } else {
             search = ""
+            focusedField = nil
+            clearSelection()
             composerFocused = true
         }
     }
@@ -881,3 +940,15 @@ struct PanelView: View {
         return (try? AttributedString(markdown: string, options: options)) ?? AttributedString(string)
     }
 }
+
+/// Sync status lives in its own view so a `SyncService` publish cannot
+/// invalidate the panel's list. Watching it from `PanelView`'s body meant every
+/// sync event — including the 5-second poll — re-rendered every row.
+private struct SyncDot: View {
+    @ObservedObject private var sync = SyncService.shared
+
+    var body: some View {
+        Image(systemName: "arrow.triangle.2.circlepath")
+            .foregroundStyle(sync.code == nil ? Color.secondary : Color.accentColor)
+    }
+}

Sources/Prompt/SyncService.swift

@@ -193,13 +193,20 @@ final class SyncService: ObservableObject {
 
     private func poll() {
         guard !isSyncing, let code, let versionURL = endpoint("/api/sync/\(code)/version") else { return }
+        // A cached /version would keep reporting the version the client already
+        // has, so polls must always hit the network. The responses are a few
+        // bytes; letting CFNetwork write them to the disk cache every 5 s only
+        // adds churn.
+        var versionRequest = URLRequest(url: versionURL)
+        versionRequest.cachePolicy = .reloadIgnoringLocalCacheData
+        versionRequest.timeoutInterval = 15
         Task {
             do {
                 // Cheap poll first: the full payload can be megabytes of
                 // base64 images, so only download it when the version moved.
-                let (versionData, versionResponse) = try await URLSession.shared.data(from: versionURL)
+                let (versionData, versionResponse) = try await URLSession.shared.data(for: versionRequest)
                 if (versionResponse as? HTTPURLResponse)?.statusCode == 404 {
-                    lastError = "Sync group no longer exists on the server"
+                    setError("Sync group no longer exists on the server")
                     return
                 }
                 guard let versionHTTP = versionResponse as? HTTPURLResponse, versionHTTP.statusCode == 200 else {
@@ -208,12 +215,15 @@ final class SyncService: ObservableObject {
                 }
                 let remoteVersion = try JSONDecoder().decode([String: Int64].self, from: versionData)["version"] ?? 0
                 guard remoteVersion > lastVersion else {
-                    lastError = nil
+                    setError(nil)
                     return
                 }
                 syncLog("poll remote v\(remoteVersion) local v\(lastVersion) — fetching payload")
                 guard let payloadURL = endpoint("/api/sync/\(code)") else { return }
-                let (data, response) = try await URLSession.shared.data(from: payloadURL)
+                var payloadRequest = URLRequest(url: payloadURL)
+                payloadRequest.cachePolicy = .reloadIgnoringLocalCacheData
+                payloadRequest.timeoutInterval = 30
+                let (data, response) = try await URLSession.shared.data(for: payloadRequest)
                 guard let http = response as? HTTPURLResponse, http.statusCode == 200 else { return }
                 let remote = try JSONDecoder().decode(SyncGetResponse.self, from: data)
                 if let payload = remote.data {
@@ -221,15 +231,25 @@ final class SyncService: ObservableObject {
                 } else {
                     lastVersion = remote.version
                 }
-                lastError = nil
+                setError(nil)
             } catch {
                 syncLog("poll failed: \(error.localizedDescription)")
                 // Polling errors are transient; stay quiet unless nothing ever worked.
-                if lastSyncedAt == nil { lastError = "Cannot reach sync server" }
+                if lastSyncedAt == nil { setError("Cannot reach sync server") }
             }
         }
     }
 
+    /// `@Published` fires on every assignment, even when the value is
+    /// unchanged. The 5-second poll would otherwise republish `lastError`
+    /// forever, and since `PanelView` observes this object, the whole panel
+    /// (list, rows, overlays) re-rendered every 5 seconds — the app grew to
+    /// ~190 MB and ~90 ms of layout per poll over five days of uptime.
+    private func setError(_ message: String?) {
+        guard lastError != message else { return }
+        lastError = message
+    }
+
     private func restartPolling() {
         pollTimer?.invalidate()
         pollTimer = nil