Fix window hover detection; add redaction tool

Window detection was broken by wrong CG-to-AppKit coordinate conversion
of the cursor and highlight rects — both now go through the same
cgToAppKit mapping. The draw toolbar gains a Pen/Redact toggle: redact
drags cover content with a solid black bar (participates in undo/redo
and export like pen strokes).

💘 Generated with Crush

Assisted-by: Crush:deepseek-v4-flash-0731

.gitignore

@@ -5,6 +5,9 @@
 # App bundle (build artifact, regenerate with ./build-app.sh)
 Kapture.app/
 
+# Secrets
+*.p8
+
 # macOS
 .DS_Store
 

AGENTS.md

@@ -0,0 +1,112 @@
+# AGENTS.md
+
+Kapture is a native macOS menu-bar screenshot + OCR app written in Swift/SwiftUI.
+Single executable SwiftPM package, no external dependencies (all Apple frameworks).
+
+## Architecture
+
+Control flow for the main path: menu bar → hotkey → overlay → capture → result window → OCR.
+
+- `Sources/Kapture/App.swift` — `@main` entry. `MenuBarExtra` menu, `AppDelegate`
+  (wires hotkey → `CaptureController.begin()`; handles `--test-ocr`), `PermissionManager`
+  (wraps `CGPreflightScreenCaptureAccess` / `CGRequestScreenCaptureAccess`).
+- `Sources/Kapture/HotkeyManager.swift` — Carbon `RegisterEventHotKey`, hardcoded
+  ⌘⇧S (`kVK_ANSI_S`, `cmdKey | shiftKey`), signature `0x4B505452`.
+- `Sources/Kapture/CaptureController.swift` — selection flow. Creates one borderless
+  `NSPanel` overlay per screen, then captures via `ScreenCapture` and hands the image
+  to `ResultWindow`. Coordination happens in `begin()`/`finishSelection()`/`cancelSelection()`.
+- `Sources/Kapture/ScreenCapture` (same file) — macOS 14+: ScreenCaptureKit
+  `SCScreenshotManager` + manual pixel-space crop (`display.width / display.frame.width`
+  scale); macOS 13: `CGWindowListCreateImage` fallback.
+- `Sources/Kapture/OverlayView.swift` — `NSPanel` + `NSView` drawing overlay; mouse-driven
+  rect selection (min 2×2 pt), Escape (keyCode 53) cancels; selection committed via
+  `window.convertToScreen` (screen coordinates).
+- `Sources/Kapture/OCRService.swift` — Vision `VNRecognizeTextRequest`, `.accurate`
+  level, languages `["en-US", "zh-Hans", "zh-Hant", "ja-JP", "ko-KR"]`. Custom
+  line-order sort: observations sorted top→bottom by `boundingBox.midY` (tolerance
+  `0.02`), then left→right. Runs on a private serial `DispatchQueue`
+  (`dev.tzgyn.kapture.ocr`), completes on that queue — callers must hop back to main.
+- `Sources/Kapture/ResultWindow.swift` — `ResultWindow.show(image:)` (single shared
+  floating window, closes previous), `CaptureModel` (ObservableObject, `@Published`
+  `mode` = screenshot/text), `ResultView` (SwiftUI, Screenshot/Text tabs, Get Text /
+  Save PNG / Copy Text).
+
+Singletons everywhere: `HotkeyManager.shared`, `CaptureController.shared`,
+`ScreenCapture.shared`, `OCRService.shared`, `ResultWindow.shared`.
+
+Note: packaging references `dev.tzgyn.kapture` as the bundle identifier — match this
+in any new code (queue labels, TCC/plist references).
+
+## Commands
+
+```bash
+swift build                  # debug build (also: swift run Kapture)
+swift build -c release       # release build (what build-app.sh uses)
+swift run Kapture            # dev run from terminal (app appears in Dock)
+swift run Kapture --test-ocr # OCR smoke test: renders text, OCRs it, prints PASS/FAIL, exit 0/1
+./build-app.sh               # release build + Kapture.app bundle + icon + ad-hoc codesign
+./release.sh <version>       # e.g. ./release.sh 1.0.1: builds app, zips to dist/Kapture.zip, prints sha256
+scripts/make-icon.sh         # regenerates Kapture.app/Contents/Resources/Icon.icns from scripts/gen-icon.swift
+```
+
+There is no test target and no linter/formatter configured. Verification = build +
+`--test-ocr`.
+
+## Bundle build & signing
+
+`build-app.sh` does: release build → handwritten `Info.plist` (NOT generated from
+`Package.swift`) → `make-icon.sh` → `codesign` with self-signed identity `kapture-dev`
+stored in a dedicated keychain at `~/.config/kapture/signing.keychain-db` (not the
+login keychain). Honest bugs to keep in mind:
+
+- Uses `security create-keychain`/`unlock-keychain` with a hardcoded password
+  (`kapture-dev`) — if the cert creation fails midway, the keychain may be left in an
+  undefined state; the script is mostly idempotent but re-run it before assuming failure.
+- The self-signed cert is created with Homebrew OpenSSL (`/opt/homebrew/bin/openssl`,
+  falls back to `/usr/local/bin/openssl`, then system `openssl`) and imported as a
+  pkcs12 (`-export -legacy`). The legacy flag is important — modern OpenSSL defaults
+  to formats the macOS `security` tool rejects.
+- `LSUIElement` = true → no Dock icon. Info.plist also hardcodes
+  `CFBundleShortVersionString` 1.0 / `CFBundleVersion` 1 — bump here for releases,
+  and match it in `release.sh` args.
+
+macOS may require re-granting Screen Recording permission when the binary identity
+changes (TCC tracks the binary, not the source).
+
+## Release process
+
+1. `./release.sh <version>` — builds, zips `Kapture.app` to `dist/Kapture.zip`,
+   prints its sha256 (that's all it does, it does not tag or upload).
+2. Tag `git tag v<version> && git push origin v<version>` and attach the zip to a
+   GitHub release manually (the old `.github/workflows/release.yml` was removed;
+   `release.sh` output still says the workflow will upload the zip, which is stale).
+3. The Homebrew cask lives in `TZGyn/homebrew-tap` — bump `version` and `sha256`
+   there for each release.
+
+Icon note: the cask references the `Icon.icns` built into the app bundle, so no
+separate icon release step needed.
+
+## Gotchas
+
+- Coordinate spaces differ: overlay selections are in global screen points
+  (via `convertToScreen`), ScreenCaptureKit images are in pixels and the crop must
+  scale by `display.width / display.frame.width`. Don't mix them.
+- Starting on macOS 13 vs 14 changes the capture path: 13 uses the `CGWindowListCreateImage`
+  fallback, which only handles the primary screen (`frame.origin == .zero`) and
+  needs explicit Y-flip (`primary.frame.height - rect.maxY`). Get selection rect
+  handling wrong on one path and you break only one OS version — test on both.
+- When selection overlays are active for more than one screen macOS may also be
+  capturing the overlay panels themselves while the selection is running; the overlay
+  windows' `windowNumber` IDs are collected in `begin()` and excluded via
+  `SCContentFilter(excludingWindows:)` when capturing. If you add any new window that
+  shows during overlay/selection, add it to the exclusion set.
+- The OCR completion runs on a background queue — never touch `CaptureModel`/UI from
+  it; `runOCR` hops to `@MainActor` via `Task { @MainActor in ... }`.
+- `--test-ocr` is processed in `AppDelegate.applicationDidFinishLaunching` and must
+  `exit()` with 0/1 inside the completion; the `RunLoop.main.run()` after is what keeps
+  the process alive until the async OCR finishes. If OCR returns empty text it
+  doesn't crash — just prints FAIL.
+- No `@MainActor` annotations on AppDelegate / HotkeyManager; keep new code on main
+  thread for AppKit calls.
+- `.gitignore` covers `.build/`, `Kapture.app/`, `dist/` — build artifacts should
+  never be committed.

README.md

@@ -13,6 +13,7 @@ No network calls, no API keys — everything runs locally.
 
 - Global hotkey **⌘⇧S** works from any app
 - Region selection overlay (all screens, Escape cancels)
+- **Launch at Login** toggle in the menu bar
 - The screenshot appears in a window (Screenshot / Text tabs) instead of being
   instantly OCR'd
 - **Get Text** button runs on-device OCR (English, Chinese simplified/traditional,
@@ -21,6 +22,27 @@ No network calls, no API keys — everything runs locally.
 - Open an existing image file (or drag) via the menu bar icon
 - Menu bar icon with permission status
 
+## Install with Homebrew
+
+```bash
+brew tap TZGyn/tap https://gitea.tzgyn.dev/TZGyn/homebrew-tap.git
+brew trust TZGyn/tap
+brew install --cask kapture
+```
+
+The tap is hosted on Gitea, so the full URL is required. Homebrew may print
+an "Unsupported tap" warning — it's harmless.
+
+Releases are published as zips on GitHub Releases; `release.sh` packages a
+new one (`./release.sh 1.0.1 && git tag v1.0.1 && git push origin v1.0.1`).
+The cask lives in the [TZGyn/homebrew-tap](https://github.com/TZGyn/homebrew-tap)
+repository — bump the `version` and `sha256` there for each release.
+
+Note: builds are ad-hoc signed (no App Store / Developer ID notarization), so
+first launch of a new version may trigger a Gatekeeper warning — users can
+right-click → Open, or the warning goes away when the binary identity matches a
+previously-granted permission.
+
 ## Build & run
 
 ```bash

Sources/Kapture/App.swift

@@ -1,6 +1,7 @@
 import SwiftUI
 import AppKit
 import CoreGraphics
+import ServiceManagement
 
 @main
 struct KaptureApp: App {
@@ -47,6 +48,26 @@ struct MenuView: View {
 
         Divider()
 
+        Button("Copy Diagnostics") {
+            let diag = CaptureController.shared.diagnostics()
+            let pasteboard = NSPasteboard.general
+            pasteboard.clearContents()
+            pasteboard.setString(diag, forType: .string)
+        }
+
+        Button(LoginItem.isEnabled ? "Disable Launch at Login" : "Launch at Login") {
+            if !LoginItem.toggle() {
+                let alert = NSAlert()
+                alert.messageText = "Could not update Launch at Login"
+                alert.informativeText = "Launch at Login requires a signed app bundle in /Applications. It is not available when running via `swift run`."
+                alert.alertStyle = .warning
+                alert.addButton(withTitle: "OK")
+                alert.runModal()
+            }
+        }
+
+        Divider()
+
         Button("Quit Kapture") { NSApp.terminate(nil) }
             .keyboardShortcut("q")
     }
@@ -60,6 +81,26 @@ enum PermissionManager {
     }
 }
 
+enum LoginItem {
+    static var isEnabled: Bool {
+        SMAppService.mainApp.status == .enabled
+    }
+
+    static func toggle() -> Bool {
+        let service = SMAppService.mainApp
+        do {
+            if service.status == .enabled {
+                try service.unregister()
+            } else {
+                try service.register()
+            }
+            return true
+        } catch {
+            return false
+        }
+    }
+}
+
 func runOCRSelfTest() {
     let text = "Kapture OCR test 1234, hello world"
     let size = NSSize(width: 1600, height: 220)

Sources/Kapture/CaptureController.swift

@@ -10,6 +10,38 @@ final class CaptureController: NSObject {
     private var previousApp: NSRunningApplication?
     private var overlayIDs: [Int] = []
 
+    /// Diagnostic snapshot for "Copy Diagnostics" menu item.
+    func diagnostics() -> String {
+        var lines: [String] = []
+        lines.append("Kapture diagnostics")
+        for (i, s) in NSScreen.screens.enumerated() {
+            let scale = s.backingScaleFactor
+            let cgID = (s.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? NSNumber)?.uint32Value ?? 0
+            lines.append("screen[\(i)]: frame=\(s.frame) scale=\(scale) backingSize=\(s.frame.width*scale)x\(s.frame.height*scale) cgID=\(cgID)")
+        }
+        if #available(macOS 14.0, *) {
+            Task {
+                if let content = try? await SCShareableContent.current {
+                    for (i, d) in content.displays.enumerated() {
+                        lines.append("SCDisplay[\(i)]: frame=\(d.frame) width=\(d.width)x\(d.height) id=\(d.displayID)")
+                    }
+                } else {
+                    lines.append("SCShareableContent: unavailable (no Screen Recording permission?)")
+                }
+                let text = lines.joined(separator: "\n")
+                let pb = NSPasteboard.general
+                pb.clearContents()
+                pb.setString(text, forType: .string)
+            }
+        } else {
+            let text = lines.joined(separator: "\n")
+            let pb = NSPasteboard.general
+            pb.clearContents()
+            pb.setString(text, forType: .string)
+        }
+        return lines.joined(separator: "\n")
+    }
+
     func begin() {
         guard !isSelecting else { return }
         guard PermissionManager.isGranted else {
@@ -27,13 +59,25 @@ final class CaptureController: NSObject {
             OverlayWindow(
                 screen: screen,
                 onComplete: { [weak self] rect in self?.finishSelection(rect) },
-                onCancel: { [weak self] in self?.cancelSelection() }
+                onCancel: { [weak self] in self?.cancelSelection() },
+                onWindowPick: { [weak self] rect in self?.finishWindowPick(rect) }
             )
         }
         overlays.forEach { $0.makeKeyAndOrderFront(nil) }
         overlayIDs = overlays.map { $0.windowNumber }
     }
 
+    /// A window was picked from hover — capture it with rounded corners.
+    private func finishWindowPick(_ rect: NSRect) {
+        let ids = overlayIDs
+        hideOverlays()
+        isSelecting = false
+        restorePreviousApp()
+        DispatchQueue.main.async { [self] in
+            capture(rect, excludingWindowIDs: ids, roundedCorners: true)
+        }
+    }
+
     private func finishSelection(_ rect: NSRect) {
         let ids = overlayIDs
         hideOverlays()
@@ -62,8 +106,8 @@ final class CaptureController: NSObject {
         previousApp = nil
     }
 
-    private func capture(_ rect: NSRect, excludingWindowIDs ids: [Int]) {
+    private func capture(_ rect: NSRect, excludingWindowIDs ids: [Int], roundedCorners: Bool = false) {
-        ScreenCapture.shared.capture(rect, excludingWindowIDs: ids) { [weak self] image in
+        ScreenCapture.shared.capture(rect, excludingWindowIDs: ids, roundedCorners: roundedCorners) { [weak self] image in
             DispatchQueue.main.async {
                 self?.isSelecting = false
                 self?.restorePreviousApp()
@@ -85,30 +129,56 @@ final class ScreenCapture {
     private init() {}
 
     @available(macOS 14.0, *)
-    private func crop(_ image: CGImage, to rect: NSRect, display: SCDisplay) -> CGImage? {
+    private func crop(_ image: CGImage, to cgRect: CGRect, display: SCDisplay, roundedCorners: Bool = false) -> CGImage? {
-        let scaleX = CGFloat(display.width) / display.frame.width
+        // cgRect is in SCDisplay space (bottom-left origin, Y flipped vs AppKit).
-        let scaleY = CGFloat(display.height) / display.frame.height
+        // The captured image has a TOP-LEFT origin. So within the display,
-        let cgRect = CGRect(
+        // we must flip Y: pixelY = displayHeight - (cgY - displayMinY) - cgHeight.
-            x: rect.minX,
+        let scaleX = CGFloat(image.width) / display.frame.width
-            y: rect.minY,
+        let scaleY = CGFloat(image.height) / display.frame.height
-            width: rect.width,
+        guard scaleX > 0, scaleY > 0 else { return nil }
-            height: rect.height
+        let localMinX = cgRect.minX - display.frame.minX
-        )
+        let localMaxY = cgRect.maxY - display.frame.minY
+        let flippedY = display.frame.height - localMaxY
         let pxRect = CGRect(
-            x: (cgRect.minX - display.frame.minX) * scaleX,
+            x: localMinX * scaleX,
-            y: (cgRect.minY - display.frame.minY) * scaleY,
+            y: flippedY * scaleY,
             width: cgRect.width * scaleX,
             height: cgRect.height * scaleY
         )
-        guard let cropCtx = CGContext(
+        // Guard against negative offsets when the selection reaches beyond the
-            data: nil, width: Int(pxRect.width), height: Int(pxRect.height),
+        // display's frame (e.g. secondary monitor coordinate quirks).
-            bitsPerComponent: 8, bytesPerRow: 0,
+        let safeRect = pxRect.intersection(CGRect(x: 0, y: 0, width: CGFloat(image.width), height: CGFloat(image.height)))
-            space: CGColorSpaceCreateDeviceRGB(),
+        guard safeRect.width >= 1, safeRect.height >= 1 else { return nil }
-            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+        // Use a pixel-exact subimage crop instead of redrawing through a
-        ) else { return nil }
+        // CGContext, which resamples and loses quality on retina captures.
-        cropCtx.interpolationQuality = .high
+        let rounded = safeRect.integral
-        cropCtx.draw(image, in: CGRect(x: -pxRect.minX, y: -pxRect.minY, width: CGFloat(image.width), height: CGFloat(image.height)))
+        guard rounded.width >= 1, rounded.height >= 1 else { return nil }
-        return cropCtx.makeImage()
+        guard var result = image.cropping(to: rounded) else { return nil }
+
+        // Apply a rounded-corner alpha mask for window captures, matching
+        // macOS window chrome (≈10pt radius, scaled to image pixels).
+        if roundedCorners {
+            let radius = 10 * scaleX
+            let maskRect = CGRect(x: 0, y: 0, width: result.width, height: result.height)
+            guard let maskCtx = CGContext(
+                data: nil, width: result.width, height: result.height,
+                bitsPerComponent: 8, bytesPerRow: 0,
+                space: CGColorSpaceCreateDeviceRGB(),
+                bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+            ) else { return result }
+            maskCtx.setFillColor(CGColor(gray: 1, alpha: 1))
+            maskCtx.fill(maskRect)
+            maskCtx.setBlendMode(.clear)
+            maskCtx.setFillColor(CGColor(gray: 0, alpha: 1))
+            maskCtx.addPath(CGPath(roundedRect: maskRect, cornerWidth: radius, cornerHeight: radius, transform: nil))
+            maskCtx.fillPath()
+            maskCtx.setBlendMode(.normal)
+            if let mask = maskCtx.makeImage(),
+               let masked = result.masking(mask) {
+                result = masked
+            }
+        }
+        return result
     }
 
     @available(macOS 14.0, *)
@@ -121,7 +191,7 @@ final class ScreenCapture {
         return content.displays.first(where: { $0.displayID == cgID }) ?? content.displays.first
     }
 
-    func capture(_ rect: NSRect, excludingWindowIDs excludedIDs: [Int], completion: @escaping (CGImage?) -> Void) {
+    func capture(_ rect: NSRect, excludingWindowIDs excludedIDs: [Int], roundedCorners: Bool = false, completion: @escaping (CGImage?) -> Void) {
         if #available(macOS 14.0, *) {
             Task {
                 guard let content = try? await SCShareableContent.current,
@@ -133,15 +203,34 @@ final class ScreenCapture {
                 let excluded = content.windows.filter { excludedSet.contains($0.windowID) }
                 let filter = SCContentFilter(display: display, excludingWindows: excluded)
                 let config = SCStreamConfiguration()
-                config.width = Int(display.width)
+                // SCDisplay.width/height are in POINTS; SCStreamConfiguration
-                config.height = Int(display.height)
+                // width/height are output PIXELS. Multiply by the backing scale
+                // of the screen containing the selection so retina displays are
+                // captured at full resolution and 1x displays stay 1x.
+                guard let screen = NSScreen.screens.first(where: { $0.frame.contains(NSPoint(x: rect.midX, y: rect.midY)) }) else {
+                    completion(nil)
+                    return
+                }
+                let backingScale = screen.backingScaleFactor
+                config.width = Int(CGFloat(display.width) * backingScale)
+                config.height = Int(CGFloat(display.height) * backingScale)
                 config.showsCursor = true
 
+                // ScreenCaptureKit uses a different origin than AppKit for
+                // screens stacked around the main display: per-display,
+                // SCDisplay y = appKitY - NSScreen.maxY + SCDisplay.maxY.
+                let scRect = CGRect(
+                    x: rect.minX,
+                    y: rect.minY - screen.frame.maxY + display.frame.maxY,
+                    width: rect.width,
+                    height: rect.height
+                )
+
                 guard let image = try? await SCScreenshotManager.captureImage(contentFilter: filter, configuration: config) else {
                     completion(nil)
                     return
                 }
-                completion(self.crop(image, to: rect, display: display))
+                completion(self.crop(image, to: scRect, display: display, roundedCorners: roundedCorners))
             }
         } else {
             guard let primary = NSScreen.screens.first(where: { $0.frame.origin == .zero }) ?? NSScreen.screens.first else {

Sources/Kapture/OverlayView.swift

@@ -1,8 +1,8 @@
 import AppKit
 
 final class OverlayWindow: NSPanel {
-    init(screen: NSScreen, onComplete: @escaping (NSRect) -> Void, onCancel: @escaping () -> Void) {
+    init(screen: NSScreen, onComplete: @escaping (NSRect) -> Void, onCancel: @escaping () -> Void, onWindowPick: @escaping (NSRect) -> Void) {
-        let content = OverlayView(onComplete: onComplete, onCancel: onCancel)
+        let content = OverlayView(onComplete: onComplete, onCancel: onCancel, onWindowPick: onWindowPick)
         super.init(
             contentRect: screen.frame,
             styleMask: [.borderless, .nonactivatingPanel],
@@ -25,13 +25,21 @@ final class OverlayWindow: NSPanel {
 final class OverlayView: NSView {
     private let onComplete: (NSRect) -> Void
     private let onCancel: () -> Void
+    private let onWindowPick: (NSRect) -> Void
 
     private var startPoint: NSPoint?
     private(set) var selection: NSRect?
+    private var isDragging = false
 
-    init(onComplete: @escaping (NSRect) -> Void, onCancel: @escaping () -> Void) {
+    // Window detection
+    private var trackedWindows: [(id: CGWindowID, frame: NSRect)] = []
+    private var hoveredWindowFrame: NSRect?
+    private var excludedIDs: [Int] = []
+
+    init(onComplete: @escaping (NSRect) -> Void, onCancel: @escaping () -> Void, onWindowPick: @escaping (NSRect) -> Void) {
         self.onComplete = onComplete
         self.onCancel = onCancel
+        self.onWindowPick = onWindowPick
         super.init(frame: .zero)
     }
 
@@ -47,6 +55,80 @@ final class OverlayView: NSView {
         addCursorRect(bounds, cursor: .crosshair)
     }
 
+    // MARK: - Window detection
+
+    /// Rebuild the list of capturable windows intersecting this screen.
+    /// Called lazily on mouse moves; cheap enough for interactive hover.
+    private func refreshTrackedWindows() {
+        guard let window = window else { return }
+        let screenFrame = window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
+        // Exclude this overlay's own window (the other overlays don't intersect
+        // this screen, so the on-screen filter handles them).
+        let ownID = window.windowNumber
+
+        guard let list = CGWindowListCopyWindowInfo(
+            [ .optionOnScreenOnly, .excludeDesktopElements ], kCGNullWindowID
+        ) as? [[String: Any]] else { trackedWindows = []; return }
+
+        var found: [(CGWindowID, NSRect)] = []
+        for info in list {
+            guard let cid = info[kCGWindowNumber as String] as? CGWindowID,
+                  let bounds = info[kCGWindowBounds as String] as? [String: CGFloat],
+                  let layer = info[kCGWindowLayer as String] as? Int,
+                  layer == 0
+            else { continue }
+            // Skip our own overlays
+            if Int(cid) == ownID { continue }
+            let rect = NSRect(
+                x: bounds["X"] ?? 0,
+                y: bounds["Y"] ?? 0,
+                width: bounds["Width"] ?? 0,
+                height: bounds["Height"] ?? 0
+            )
+            guard rect.width >= 80, rect.height >= 60 else { continue }
+            // Skip tiny/utility windows
+            guard rect.width < screenFrame.width || rect.height < screenFrame.height else { continue }
+            // Only windows intersecting this screen
+            guard rect.intersects(screenFrame) else { continue }
+            found.append((cid, rect))
+        }
+        trackedWindows = found
+    }
+
+    private func windowFrame(at point: NSPoint) -> NSRect? {
+        guard let window = window else { return nil }
+        // convertToScreen gives AppKit-global coordinates; convert tracked
+        // CG frames to the same space and pick the frontmost containing it.
+        let screenPoint = window.convertToScreen(NSRect(origin: point, size: .zero)).origin
+        for (_, frame) in trackedWindows {
+            if Self.cgToAppKit(rect: frame).contains(screenPoint) {
+                return frame
+            }
+        }
+        return nil
+    }
+
+    /// Convert a CGWindowList (top-left origin, CG global space) frame into
+    /// AppKit screen coordinates (bottom-left origin) for capture.
+    private static func cgToAppKit(rect: NSRect) -> NSRect {
+        guard let mainScreen = NSScreen.screens.first else { return rect }
+        let y = mainScreen.frame.height - rect.origin.y - rect.height
+        return NSRect(x: rect.origin.x, y: y, width: rect.width, height: rect.height)
+    }
+
+    // MARK: - Events
+
+    override func mouseMoved(with event: NSEvent) {
+        guard !isDragging else { return }
+        refreshTrackedWindows()
+        let p = convert(event.locationInWindow, from: nil)
+        let frame = windowFrame(at: p)
+        if frame != hoveredWindowFrame {
+            hoveredWindowFrame = frame
+            needsDisplay = true
+        }
+    }
+
     override func mouseDown(with event: NSEvent) {
         let p = convert(event.locationInWindow, from: nil)
         startPoint = p
@@ -56,6 +138,8 @@ final class OverlayView: NSView {
 
     override func mouseDragged(with event: NSEvent) {
         guard let start = startPoint else { return }
+        isDragging = true
+        hoveredWindowFrame = nil
         let p = convert(event.locationInWindow, from: nil)
         selection = NSRect(
             x: min(start.x, p.x),
@@ -67,9 +151,20 @@ final class OverlayView: NSView {
     }
 
     override func mouseUp(with event: NSEvent) {
-        guard let sel = selection else { return }
+        if isDragging {
-        if sel.width >= 2, sel.height >= 2 {
+            guard let sel = selection else { return }
-            onComplete(window!.convertToScreen(sel))
+            if sel.width >= 2, sel.height >= 2 {
+                onComplete(window!.convertToScreen(sel))
+            } else {
+                onCancel()
+            }
+            return
+        }
+
+        // No drag: it was a click. If a window is hovered, capture it with
+        // rounded corners; otherwise treat as an empty marquee (cancel).
+        if let frame = hoveredWindowFrame {
+            onWindowPick(Self.cgToAppKit(rect: frame))
         } else {
             onCancel()
         }
@@ -87,6 +182,31 @@ final class OverlayView: NSView {
         NSColor.black.withAlphaComponent(0.35).setFill()
         NSBezierPath(rect: bounds).fill()
 
+        // Highlight the hovered window (rounded, like the real window corners)
+        if let frame = hoveredWindowFrame {
+            // Convert the CG frame to AppKit-global, then to this view's space.
+            guard let window = window else { return }
+            let screenFrame = window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
+            let appKitFrame = Self.cgToAppKit(rect: frame)
+            let viewFrame = NSRect(
+                x: appKitFrame.origin.x - screenFrame.origin.x,
+                y: appKitFrame.origin.y - screenFrame.origin.y,
+                width: frame.width,
+                height: frame.height
+            )
+            NSGraphicsContext.current?.saveGraphicsState()
+            NSGraphicsContext.current?.compositingOperation = .clear
+            NSColor.black.setFill()
+            NSBezierPath(roundedRect: viewFrame, xRadius: 10, yRadius: 10).fill()
+            NSGraphicsContext.current?.restoreGraphicsState()
+
+            let border = NSBezierPath(roundedRect: viewFrame, xRadius: 10, yRadius: 10)
+            border.lineWidth = 2
+            NSColor.controlAccentColor.setStroke()
+            border.stroke()
+            return
+        }
+
         guard let sel = selection, sel.width > 0, sel.height > 0 else { return }
 
         NSGraphicsContext.current?.saveGraphicsState()

Sources/Kapture/ResultWindow.swift

@@ -5,24 +5,44 @@ import UniformTypeIdentifiers
 final class ResultWindow {
     static let shared = ResultWindow()
 
-    private var window: NSWindow?
+    private var windows: [NSWindow] = []
+    private var nextOrigin = NSPoint(x: 60, y: 60)
+    private var openCount = 0
 
     @MainActor
     func show(image: CGImage) {
-        window?.close()
         let model = CaptureModel(image: image)
-        let hosting = NSHostingController(rootView: ResultView(model: model) { [weak self] in
+        let w = NSWindow()
-            self?.window?.close()
+        w.contentViewController = NSHostingController(rootView: ResultView(model: model) {
+            w.close()
         })
-        let w = NSWindow(contentViewController: hosting)
+        w.title = "Kapture — Screenshot" + (openCount > 0 ? " \(openCount + 1)" : "")
-        w.title = "Kapture — Screenshot"
         w.level = .floating
         w.styleMask = [.titled, .closable, .resizable]
         w.setContentSize(NSSize(width: 694, height: 520))
         w.isReleasedWhenClosed = false
-        w.center()
+        w.setFrameOrigin(nextOrigin)
         w.makeKeyAndOrderFront(nil)
-        window = w
+
+        windows.append(w)
+        openCount += 1
+        nextOrigin = NSPoint(x: nextOrigin.x + 28, y: nextOrigin.y - 28)
+
+        windowCleanup(for: w)
+    }
+
+    private func windowCleanup(for window: NSWindow) {
+        NotificationCenter.default.addObserver(
+            forName: NSWindow.willCloseNotification,
+            object: window,
+            queue: .main
+        ) { [weak self] _ in
+            Task { @MainActor in
+                guard let self else { return }
+                self.windows.removeAll { $0 === window }
+                self.openCount = max(0, self.openCount - 1)
+            }
+        }
     }
 
     @MainActor
@@ -68,6 +88,27 @@ final class CaptureModel: ObservableObject {
     @Published var extractedText: String?
     @Published var isOCRRunning = false
     @Published var statusMessage: String?
+    /// Drag selection rect in IMAGE point space (nil = none)
+    @Published var selection: CGRect?
+    /// Freehand drawing strokes in IMAGE point space
+    @Published var strokes: [Stroke] = []
+    /// Redo stack of removed strokes
+    @Published var redoStack: [Stroke] = []
+    /// Whether the pen is active (drag draws instead of selecting)
+    @Published var isDrawing = false
+    /// Whether drawing redacts (black bar) instead of pen strokes
+    @Published var isRedacting = false
+    /// Current drawing color
+    @Published var drawColor: NSColor = .systemRed
+    /// Stroke thickness in points (image space)
+    @Published var strokeWidth: CGFloat = 3.0
+
+    struct Stroke {
+        let points: [CGPoint]
+        let width: CGFloat
+        let color: NSColor
+        var isRedaction: Bool = false
+    }
 
     enum CaptureMode {
         case screenshot
@@ -78,24 +119,125 @@ final class CaptureModel: ObservableObject {
         self.image = image
     }
 
+    var hasSelection: Bool { selection != nil && selection!.width >= 2 && selection!.height >= 2 }
+    var canUndo: Bool { !strokes.isEmpty }
+    var canRedo: Bool { !redoStack.isEmpty }
+
+    func undoStroke() {
+        guard let last = strokes.popLast() else { return }
+        redoStack.append(last)
+    }
+
+    func redoStroke() {
+        guard let last = redoStack.popLast() else { return }
+        strokes.append(last)
+    }
+
+    func clearAnnotations() {
+        strokes = []
+        redoStack = []
+    }
+
+    /// Image with drawn strokes flattened in, for copy/save/export.
+    var annotatedImage: CGImage {
+        guard !strokes.isEmpty else { return image }
+        let size = NSSize(width: image.width, height: image.height)
+        guard let rep = NSBitmapImageRep(
+            bitmapDataPlanes: nil, pixelsWide: Int(size.width), pixelsHigh: Int(size.height),
+            bitsPerSample: 8, samplesPerPixel: 4, hasAlpha: true, isPlanar: false,
+            colorSpaceName: .deviceRGB, bytesPerRow: 0, bitsPerPixel: 0
+        ) else { return image }
+        NSGraphicsContext.saveGraphicsState()
+        NSGraphicsContext.current = NSGraphicsContext(bitmapImageRep: rep)
+        let ctx = NSGraphicsContext.current!.cgContext
+        // CGImage draws with a flipped Y in NSGraphicsContext
+        ctx.draw(image, in: NSRect(origin: .zero, size: size))
+        // Strokes are stored in TOP-LEFT image coordinates (from the SwiftUI
+        // canvas), but the CGContext uses a BOTTOM-LEFT origin. Flip Y so the
+        // strokes land where they were drawn.
+        ctx.saveGState()
+        ctx.translateBy(x: 0, y: size.height)
+        ctx.scaleBy(x: 1, y: -1)
+        ctx.setLineCap(.round)
+        ctx.setLineJoin(.round)
+        for stroke in strokes {
+            guard stroke.points.count > 1 else { continue }
+            if stroke.isRedaction {
+                // Redaction bar: filled black rect covering the stroke bounds,
+                // padded so it fully covers text.
+                let xs = stroke.points.map { $0.x }
+                let ys = stroke.points.map { $0.y }
+                let bar = NSRect(
+                    x: xs.min()! - 2,
+                    y: ys.min()! - 2,
+                    width: (xs.max()! - xs.min()!) + 4,
+                    height: max(stroke.width, ys.max()! - ys.min()!) + 4
+                )
+                NSColor.black.setFill()
+                NSBezierPath(rect: bar).fill()
+            } else {
+                stroke.color.setStroke()
+                ctx.setLineWidth(stroke.width)
+                ctx.beginPath()
+                ctx.move(to: stroke.points[0])
+                for point in stroke.points.dropFirst() {
+                    ctx.addLine(to: point)
+                }
+                ctx.strokePath()
+            }
+        }
+        ctx.restoreGState()
+        NSGraphicsContext.restoreGraphicsState()
+        return rep.cgImage ?? image
+    }
+
+    func addStroke(_ points: [CGPoint]) {
+        guard points.count > 1 else { return }
+        if isRedacting {
+            // Redaction: a filled black bar from start to end, as thick as the
+            // current stroke width (drawn as a rect for clean edges).
+            strokes.append(Stroke(points: points, width: max(strokeWidth, 12), color: .black, isRedaction: true))
+        } else {
+            strokes.append(Stroke(points: points, width: strokeWidth, color: drawColor))
+        }
+        redoStack = []
+    }
+
     var displayText: String {
         if isOCRRunning {
             return "Recognizing text…"
         }
-        return extractedText ?? "Text appears here — click “Get Text”."
+        return extractedText ?? "Select text in the screenshot, then click “Get Text”."
     }
 
-    func runOCR() {
+    func cropImage(to rectInImage: CGRect) -> CGImage? {
+        return image.cropping(to: rectInImage)
+    }
+
+    func runOCR(over selectionOnly: CGRect? = nil) {
         guard !isOCRRunning else { return }
         isOCRRunning = true
         statusMessage = nil
-        OCRService.shared.recognize(image) { [weak self] text in
+
+        let targetImage: CGImage
+        if let sel = selectionOnly {
+            guard let cropped = image.cropping(to: sel) else {
+                self.isOCRRunning = false
+                self.statusMessage = "Selection too small."
+                return
+            }
+            targetImage = cropped
+        } else {
+            targetImage = image
+        }
+
+        OCRService.shared.recognize(targetImage) { [weak self] text in
             Task { @MainActor in
                 guard let self else { return }
                 self.isOCRRunning = false
                 self.mode = .text
                 if text.isEmpty {
-                    self.extractedText = "No text found in the screenshot."
+                    self.extractedText = "No text found in the selection."
                 } else {
                     self.extractedText = text
                     let pasteboard = NSPasteboard.general
@@ -107,6 +249,11 @@ final class CaptureModel: ObservableObject {
         }
     }
 
+    func runOCRSelection() {
+        guard let sel = selection, hasSelection else { return }
+        runOCR(over: sel)
+    }
+
     func copyText() {
         guard let text = extractedText else { return }
         let pasteboard = NSPasteboard.general
@@ -115,6 +262,13 @@ final class CaptureModel: ObservableObject {
         statusMessage = "Copied to clipboard."
     }
 
+    func copyImage() {
+        let pasteboard = NSPasteboard.general
+        pasteboard.clearContents()
+        pasteboard.writeObjects([NSImage(cgImage: annotatedImage, size: .zero)])
+        statusMessage = "Image copied to clipboard."
+    }
+
     func savePNG() {
         let panel = NSSavePanel()
         panel.allowedContentTypes = [.png]
@@ -124,7 +278,7 @@ final class CaptureModel: ObservableObject {
             statusMessage = "Could not create PNG file."
             return
         }
-        CGImageDestinationAddImage(dest, image, nil)
+        CGImageDestinationAddImage(dest, annotatedImage, nil)
         if CGImageDestinationFinalize(dest) {
             statusMessage = "Saved PNG."
         } else {
@@ -144,67 +298,340 @@ struct ResultView: View {
     let onClose: () -> Void
 
     var body: some View {
-        VStack(spacing: 10) {
+        VStack(spacing: 0) {
-            HStack {
+            // Toolbar
+            HStack(spacing: 10) {
                 Picker("", selection: $model.mode) {
                     Text("Screenshot").tag(CaptureModel.CaptureMode.screenshot)
                     Text("Text").tag(CaptureModel.CaptureMode.text)
-                    if model.isOCRRunning {
-                        Text("…").tag(CaptureModel.CaptureMode.text)
-                    }
                 }
                 .pickerStyle(.segmented)
                 .fixedSize()
-                Spacer()
-                Button("Save PNG…") { model.savePNG() }
-                Button("Get Text") { model.runOCR() }
-                    .disabled(model.isOCRRunning || model.extractedText != nil)
-                Button("Close") { onClose() }
-            }
-            .padding(.horizontal, 12)
-            .padding(.top, 10)
 
+                Spacer()
+
+                if model.hasSelection {
+                    Button {
+                        model.runOCRSelection()
+                    } label: {
+                        Label("OCR Selection", systemImage: "text.magnifyingglass")
+                    }
+                    .buttonStyle(.borderedProminent)
+                    .disabled(model.isOCRRunning)
+                    .help("Recognize text inside the selected region")
+                }
+
+                Button {
+                    model.runOCR()
+                } label: {
+                    Label("Get All Text", systemImage: "text.viewfinder")
+                }
+                .buttonStyle(.bordered)
+                .disabled(model.isOCRRunning)
+                .help("Recognize all text in the screenshot")
+
+                Divider().frame(height: 18)
+
+                Button {
+                    model.isDrawing.toggle()
+                    if model.isDrawing { model.selection = nil }
+                } label: {
+                    Label("Draw", systemImage: model.isDrawing ? "pencil.tip.crop.circle.fill" : "pencil.tip.crop.circle")
+                }
+                .buttonStyle(.bordered)
+                .foregroundStyle(model.isDrawing ? .primary : .secondary)
+                .help("Toggle drawing on the screenshot")
+
+                Button {
+                    model.copyImage()
+                } label: {
+                    Label("Copy", systemImage: "doc.on.doc")
+                }
+                .buttonStyle(.bordered)
+                .help("Copy image to clipboard")
+
+                Button {
+                    model.savePNG()
+                } label: {
+                    Label("Save", systemImage: "square.and.arrow.down")
+                }
+                .buttonStyle(.bordered)
+                .help("Save screenshot as PNG");
+
+                Button {
+                    onClose()
+                } label: {
+                    Image(systemName: "xmark.circle.fill")
+                        .foregroundStyle(.secondary)
+                }
+                .buttonStyle(.plain)
+                .help("Close")
+            }
+            .padding(.horizontal, 14)
+            .padding(.vertical, 10)
+
+            Divider()
+
+            // Draw toolbar (only when drawing)
+            if model.isDrawing {
+                HStack(spacing: 14) {
+                    Picker("", selection: $model.isRedacting) {
+                        Label("Pen", systemImage: "pencil.tip").tag(false)
+                        Label("Redact", systemImage: "rectangle.fill").tag(true)
+                    }
+                    .pickerStyle(.segmented)
+                    .fixedSize()
+                    .help("Pen draws strokes; Redact covers text with a black bar")
+
+                    Divider().frame(height: 18)
+
+                    if !model.isRedacting {
+                        HStack(spacing: 6) {
+                            Image(systemName: "circle.fill").font(.system(size: 4))
+                            Image(systemName: "circle.fill").font(.system(size: 7))
+                            Image(systemName: "circle.fill").font(.system(size: 10))
+                        }
+                        .foregroundStyle(.secondary)
+                        Slider(value: $model.strokeWidth, in: 1...12, step: 0.5)
+                            .frame(width: 120)
+                            .help("Stroke thickness")
+
+                        Divider().frame(height: 18)
+
+                        ColorPicker("", selection: Binding(
+                            get: { Color(nsColor: model.drawColor) },
+                            set: { model.drawColor = NSColor($0) }
+                        ), supportsOpacity: false)
+                        .labelsHidden()
+                        .frame(width: 28)
+                        .help("Drawing color")
+                    }
+
+                    Spacer()
+
+                    Button {
+                        model.undoStroke()
+                    } label: {
+                        Label("Undo", systemImage: "arrow.uturn.backward")
+                    }
+                    .buttonStyle(.bordered)
+                    .controlSize(.small)
+                    .disabled(!model.canUndo)
+                    .keyboardShortcut("z", modifiers: .command)
+                    .help("Undo last stroke (⌘Z)")
+
+                    Button {
+                        model.redoStroke()
+                    } label: {
+                        Label("Redo", systemImage: "arrow.uturn.forward")
+                    }
+                    .buttonStyle(.bordered)
+                    .controlSize(.small)
+                    .disabled(!model.canRedo)
+                    .keyboardShortcut("z", modifiers: [.command, .shift])
+                    .help("Redo stroke (⌘⇧Z)")
+
+                    Button {
+                        model.clearAnnotations()
+                    } label: {
+                        Label("Clear", systemImage: "eraser")
+                    }
+                    .buttonStyle(.bordered)
+                    .controlSize(.small)
+                    .disabled(model.strokes.isEmpty)
+                    .help("Remove all drawn annotations")
+                }
+                .padding(.horizontal, 14)
+                .padding(.vertical, 8)
+                .background(.bar)
+
+                Divider()
+            }
+
+            // Content
             if model.mode == .screenshot {
-                Image(nsImage: NSImage(cgImage: model.image, size: .zero))
+                ScreenshotPane(model: model)
-                    .resizable()
+                    .padding(12)
-                    .aspectRatio(contentMode: .fit)
-                    .border(Color.secondary.opacity(0.4))
-                    .padding(.horizontal, 12)
             } else {
-                ZStack(alignment: .bottomTrailing) {
+                ZStack {
                     ScrollView {
                         Text(model.displayText)
-                            .font(.system(.body))
+                            .font(.system(.body, design: .monospaced))
                             .textSelection(.enabled)
                             .frame(maxWidth: .infinity, alignment: .leading)
-                            .padding(8)
+                            .padding(12)
                     }
-                    .overlay(
+                }
-                        RoundedRectangle(cornerRadius: 6)
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
-                            .stroke(Color.secondary.opacity(0.4))
+            }
-                    )
 
-                    HStack(spacing: 8) {
+            // Status bar
-                        if let msg = model.statusMessage {
+            HStack(spacing: 8) {
-                            Text(msg)
+                if model.isOCRRunning {
-                                .font(.caption)
+                    ProgressView()
-                                .foregroundColor(.secondary)
+                        .controlSize(.small)
-                        }
+                }
-                        Button("Copy Text") { model.copyText() }
+                Text(model.statusMessage ?? (model.mode == .screenshot
+                    ? (model.hasSelection ? "Region selected — click OCR Selection." : "Drag to select a region, or Get All Text.")
+                    : "Selectable text"))
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                    .lineLimit(1)
+
+                Spacer()
+
+                if model.mode == .text, model.extractedText != nil {
+                    Button {
+                        model.copyText()
+                    } label: {
+                        Label("Copy Text", systemImage: "doc.on.doc")
                     }
-                    .padding(8)
+                    .buttonStyle(.bordered)
+                    .controlSize(.small)
                 }
             }
+            .padding(.horizontal, 14)
+            .padding(.vertical, 8)
+            .background(.bar)
+        }
+        .frame(minWidth: 520, minHeight: 420)
+    }
+}
 
-            if model.statusMessage != nil && model.mode == .screenshot {
+struct ScreenshotPane: View {
-                Text(model.statusMessage!)
+    @ObservedObject var model: CaptureModel
-                    .font(.caption)
+
-                    .foregroundColor(.secondary)
+    private var imageSize: CGSize {
-                    .frame(maxWidth: .infinity, alignment: .leading)
+        CGSize(width: model.image.width, height: model.image.height)
-                    .padding(.horizontal, 12)
+    }
+
+    private func geometry(for geo: GeometryProxy) -> (scale: CGFloat, drawSize: CGSize, origin: CGPoint) {
+        let size = imageSize
+        let scale = min(geo.size.width / size.width, geo.size.height / size.height)
+        let drawSize = CGSize(width: size.width * scale, height: size.height * scale)
+        let origin = CGPoint(
+            x: (geo.size.width - drawSize.width) / 2,
+            y: (geo.size.height - drawSize.height) / 2
+        )
+        return (scale, drawSize, origin)
+    }
+
+    private func toImagePoint(_ viewPoint: CGPoint, scale: CGFloat, origin: CGPoint) -> CGPoint {
+        CGPoint(
+            x: (viewPoint.x - origin.x) / scale,
+            y: (viewPoint.y - origin.y) / scale
+        )
+    }
+
+    private func clampSelection(_ rect: CGRect) -> CGRect {
+        rect.intersection(CGRect(origin: .zero, size: imageSize))
+    }
+
+    @State private var currentStroke: [CGPoint] = []
+
+    var body: some View {
+        GeometryReader { geo in
+            let (scale, drawSize, origin) = geometry(for: geo)
+
+            ZStack {
+                Image(nsImage: NSImage(cgImage: model.image, size: .zero))
+                    .resizable()
+                    .interpolation(imageSize.width >= geo.size.width ? .high : .none)
+                    .aspectRatio(contentMode: .fit)
+                    .frame(width: drawSize.width, height: drawSize.height)
+                    .position(x: origin.x + drawSize.width / 2, y: origin.y + drawSize.height / 2)
+
+                // Completed strokes
+                Canvas { context, _ in
+                    for stroke in model.strokes {
+                        guard stroke.points.count > 1 else { continue }
+                        if stroke.isRedaction {
+                            let xs = stroke.points.map { $0.x }
+                            let ys = stroke.points.map { $0.y }
+                            let bar = CGRect(
+                                x: origin.x + (xs.min()! - 2) * scale,
+                                y: origin.y + (ys.min()! - 2) * scale,
+                                width: ((xs.max()! - xs.min()!) + 4) * scale,
+                                height: (max(stroke.width, ys.max()! - ys.min()!) + 4) * scale
+                            )
+                            context.fill(Path(bar), with: .color(.black))
+                        } else {
+                            var path = Path()
+                            path.move(to: CGPoint(x: origin.x + stroke.points[0].x * scale, y: origin.y + stroke.points[0].y * scale))
+                            for point in stroke.points.dropFirst() {
+                                path.addLine(to: CGPoint(x: origin.x + point.x * scale, y: origin.y + point.y * scale))
+                            }
+                            context.stroke(path, with: .color(Color(nsColor: stroke.color)), lineWidth: stroke.width)
+                        }
+                    }
+                }
+                .allowsHitTesting(false)
+
+                // In-progress stroke
+                if !currentStroke.isEmpty {
+                    Canvas { context, _ in
+                        var path = Path()
+                        if currentStroke.count > 1 {
+                            path.move(to: CGPoint(x: origin.x + currentStroke[0].x * scale, y: origin.y + currentStroke[0].y * scale))
+                            for point in currentStroke.dropFirst() {
+                                path.addLine(to: CGPoint(x: origin.x + point.x * scale, y: origin.y + point.y * scale))
+                            }
+                        }
+                        context.stroke(path, with: .color(Color(nsColor: model.drawColor)), lineWidth: model.strokeWidth)
+                    }
+                    .allowsHitTesting(false)
+                }
+
+                if !model.isDrawing, let sel = model.selection {
+                    let viewRect = CGRect(
+                        x: origin.x + sel.minX * scale,
+                        y: origin.y + sel.minY * scale,
+                        width: sel.width * scale,
+                        height: sel.height * scale
+                    )
+                    Rectangle()
+                        .fill(Color.accentColor.opacity(0.15))
+                        .border(Color.accentColor, width: 1.5)
+                        .frame(width: viewRect.width, height: viewRect.height)
+                        .position(x: viewRect.midX, y: viewRect.midY)
+                        .allowsHitTesting(false)
+                }
             }
+            .contentShape(Rectangle())
+            .gesture(
+                DragGesture(minimumDistance: 0)
+                    .onChanged { value in
+                        if model.isDrawing {
+                            let p = toImagePoint(value.location, scale: scale, origin: origin)
+                            let imgRect = CGRect(origin: .zero, size: imageSize)
+                            if imgRect.contains(p) {
+                                currentStroke.append(p)
+                            }
+                        } else {
+                            let start = toImagePoint(value.startLocation, scale: scale, origin: origin)
+                            let current = toImagePoint(value.location, scale: scale, origin: origin)
+                            let rect = CGRect(
+                                x: min(start.x, current.x),
+                                y: min(start.y, current.y),
+                                width: abs(current.x - start.x),
+                                height: abs(current.y - start.y)
+                            )
+                            model.selection = clampSelection(rect)
+                        }
+                    }
+                    .onEnded { _ in
+                        if model.isDrawing {
+                            if currentStroke.count > 1 {
+                                model.addStroke(currentStroke)
+                            }
+                            currentStroke = []
+                        } else {
+                            if let s = model.selection, (s.width < 2 || s.height < 2) {
+                                model.selection = nil
+                            }
+                        }
+                    }
+            )
         }
-        .padding(.bottom, 10)
-        .frame(minWidth: 480, minHeight: 380)
     }
 }

build-app.sh

@@ -12,6 +12,28 @@ KEYCHAIN="$SIGN_DIR/signing.keychain-db"
 KCHAIN_PASS="kapture-dev"
 mkdir -p "$SIGN_DIR"
 
+# Prefer a Developer ID Application identity (login keychain) so the app gets
+# clean Gatekeeper behavior; fall back to the self-signed "kapture-dev" identity.
+# Resolve by keychain path to avoid ambiguous matches.
+DEV_IDENT=""
+if command -v security >/dev/null 2>&1; then
+    DEV_IDENT=$(security find-identity -v -p codesigning 2>/dev/null | awk '/Developer ID Application:/ { print $2; exit }')
+fi
+SIGN_KEYCHAIN=""
+if [ -n "$DEV_IDENT" ]; then
+    CERT="$DEV_IDENT"
+    echo "Using Developer ID identity: $CERT"
+    # Ensure the login keychain holding the Dev ID is unlocked & accessible.
+    security unlock-keychain "$HOME/Library/Keychains/login.keychain-db" 2>/dev/null || true
+    security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "" "$HOME/Library/Keychains/login.keychain-db" >/dev/null 2>&1 || true
+    SIGN_KEYCHAIN="$HOME/Library/Keychains/login.keychain-db"
+else
+    CERT="kapture-dev"
+    echo "Using self-signed identity 'kapture-dev'"
+    SIGN_KEYCHAIN="$KEYCHAIN"
+fi
+DEV_IDENT="${DEV_IDENT:-}"  # ensure set for later use
+
 if [ ! -f "$KEYCHAIN" ]; then
     security create-keychain -p "$KCHAIN_PASS" "$KEYCHAIN" 2>/dev/null
     security set-keychain-settings -lut 86400 "$KEYCHAIN"
@@ -86,9 +108,9 @@ cat > "$APP/Contents/Info.plist" <<'PLIST'
     <key>CFBundleIconFile</key>
     <string>Icon</string>
     <key>CFBundleShortVersionString</key>
-    <string>1.0</string>
+    <string>1.5.1</string>
     <key>CFBundleVersion</key>
-    <string>1</string>
+    <string>51</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>
@@ -102,6 +124,14 @@ PLIST
 chmod +x scripts/make-icon.sh
 ./scripts/make-icon.sh
 
-codesign --force --sign "$CERT" --keychain "$KEYCHAIN" "$APP"
+if [ -n "$SIGN_KEYCHAIN" ]; then
+    codesign --force --options runtime --sign "$CERT" --keychain "$SIGN_KEYCHAIN" "$APP"
+else
+    codesign --force --sign "$CERT" "$APP"
+fi
 
-echo "Built $APP (signed with stable identity '$CERT') — drag to /Applications or run: open $APP"
+if [ -n "$DEV_IDENT" ]; then
+    echo "Built $APP (signed with Developer ID '$CERT') — drag to /Applications or run: open $APP"
+else
+    echo "Built $APP (signed with stable identity '$CERT') — drag to /Applications or run: open $APP"
+fi

release.sh

@@ -8,14 +8,83 @@ if [ "$#" -ne 1 ]; then
 fi
 VERSION="$1"
 
+# Notarization credentials. Configure once, e.g. in ~/.zshrc:
+#   export KAPTURE_NOTARY_ASC_PROVIDER="<TeamID>"
+#   export KAPTURE_NOTARY_API_KEY_PATH="$HOME/.config/kapture/AuthKey_XXXX.p8"
+#   export KAPTURE_NOTARY_API_KEY_ID="<KeyID>"
+#   export KAPTURE_NOTARY_API_ISSUER="<IssuerID>"
+# If these are unset (or KAPTURE_SKIP_NOTARY=1), release.sh builds, zips, and stops
+# there — the zip is signed with the Developer ID identity but NOT notarized.
+
 ./build-app.sh
 
 mkdir -p dist
 rm -f dist/Kapture.zip
 ditto -c -k --keepParent Kapture.app dist/Kapture.zip
-shasum -a 256 dist/Kapture.zip
 
+if [ -n "${KAPTURE_SKIP_NOTARY:-}" ]; then
+    echo
+    echo "Skipping notarization (KAPTURE_SKIP_NOTARY set)."
+    shasum -a 256 dist/Kapture.zip
+    echo
+    echo "Tag and release with:"
+    echo "  git tag v$VERSION && git push origin v$VERSION"
+    echo "Attach dist/Kapture.zip to the GitHub release manually."
+    exit 0
+fi
+
+REQUIRED_VARS="KAPTURE_NOTARY_ASC_PROVIDER KAPTURE_NOTARY_API_KEY_PATH KAPTURE_NOTARY_API_KEY_ID KAPTURE_NOTARY_API_ISSUER"
+MISSING=""
+for v in $REQUIRED_VARS; do
+    if [ -z "${!v:-}" ]; then
+        MISSING="$MISSING $v"
+    fi
+done
+if [ -n "$MISSING" ]; then
+    echo "Notarization skipped — missing env var(s):$MISSING (see header comments)." >&2
+    shasum -a 256 dist/Kapture.zip
+    echo
+    echo "The zip above is signed but NOT notarized; Gatekeeper will warn users until it is."
+    echo "Set the KAPTURE_NOTARY_* variables and re-run ./release.sh $VERSION."
+    exit 0
+fi
+
+if ! command -v xcrun >/dev/null 2>&1 || ! xcrun --find notarytool >/dev/null 2>&1; then
+    echo "Notarization skipped — xcrun notarytool not found (requires Xcode 13+)." >&2
+    shasum -a 256 dist/Kapture.zip
+    exit 0
+fi
+
+echo "Submitting to Apple for notarization (first run can take minutes)..."
+xcrun notarytool submit dist/Kapture.zip \
+    --key "$KAPTURE_NOTARY_API_KEY_PATH" \
+    --key-id "$KAPTURE_NOTARY_API_KEY_ID" \
+    --issuer "$KAPTURE_NOTARY_API_ISSUER" \
+    --wait \
+    --output-format json > notary-result.json
+
+STATUS=$(jq -r '.status' notary-result.json 2>/dev/null || echo "unknown")
+if [ "$STATUS" != "Accepted" ]; then
+    echo "Notarization failed with status: $STATUS" >&2
+    if [ -f notary-result.json ]; then
+        cat notary-result.json >&2
+        rm -f notary-result.json
+    fi
+    exit 1
+fi
+rm -f notary-result.json
+
+echo "Notarization accepted — stapling ticket onto the app..."
+xcrun stapler staple Kapture.app
+xcrun stapler validate Kapture.app
+
+rm -f dist/Kapture.zip
+ditto -c -k --keepParent Kapture.app dist/Kapture.zip
+
+echo
+echo "Done — notarized."
+shasum -a 256 dist/Kapture.zip
 echo
 echo "Tag and release with:"
 echo "  git tag v$VERSION && git push origin v$VERSION"
-echo "The GitHub Actions release workflow will upload dist/Kapture.zip automatically."
+echo "Attach dist/Kapture.zip to the GitHub release manually; the Homebrew cask is ready."