Improve animations and resizing again. Add option for animation speed.

Downterm/CommandNotch/Components/HotkeyRecorderView.swift

@@ -28,6 +28,36 @@ struct HotkeyRecorderView: View {
     }
 }
 
+struct OptionalHotkeyRecorderView: View {
+    let label: String
+    @Binding var binding: HotkeyBinding?
+
+    @State private var isRecording = false
+
+    var body: some View {
+        HStack {
+            Text(label)
+                .frame(width: 140, alignment: .leading)
+
+            OptionalHotkeyRecorderField(binding: $binding, isRecording: $isRecording)
+                .frame(width: 120, height: 24)
+                .background(
+                    RoundedRectangle(cornerRadius: 6)
+                        .fill(isRecording ? Color.accentColor.opacity(0.15) : Color.secondary.opacity(0.1))
+                )
+                .overlay(
+                    RoundedRectangle(cornerRadius: 6)
+                        .stroke(isRecording ? Color.accentColor : Color.secondary.opacity(0.3), lineWidth: 1)
+                )
+
+            Button("Clear") {
+                binding = nil
+            }
+            .disabled(binding == nil)
+        }
+    }
+}
+
 /// NSViewRepresentable that captures key events when focused.
 struct HotkeyRecorderField: NSViewRepresentable {
     @Binding var binding: HotkeyBinding
@@ -52,6 +82,29 @@ struct HotkeyRecorderField: NSViewRepresentable {
     }
 }
 
+struct OptionalHotkeyRecorderField: NSViewRepresentable {
+    @Binding var binding: HotkeyBinding?
+    @Binding var isRecording: Bool
+
+    func makeNSView(context: Context) -> HotkeyNSView {
+        let view = HotkeyNSView()
+        view.onKeyRecorded = { newBinding in
+            binding = newBinding
+            isRecording = false
+        }
+        view.onFocusChanged = { focused in
+            isRecording = focused
+        }
+        return view
+    }
+
+    func updateNSView(_ nsView: HotkeyNSView, context: Context) {
+        nsView.currentLabel = binding?.displayString ?? "Not set"
+        nsView.showRecording = isRecording
+        nsView.needsDisplay = true
+    }
+}
+
 /// The actual NSView that handles key capture.
 class HotkeyNSView: NSView {
     var currentLabel: String = ""
@@ -59,21 +112,32 @@ class HotkeyNSView: NSView {
     var onKeyRecorded: ((HotkeyBinding) -> Void)?
     var onFocusChanged: ((Bool) -> Void)?
 
+    private let label: NSTextField = {
+        let field = NSTextField(labelWithString: "")
+        field.alignment = .center
+        field.font = NSFont.monospacedSystemFont(ofSize: 12, weight: .medium)
+        field.translatesAutoresizingMaskIntoConstraints = false
+        field.backgroundColor = .clear
+        field.isBezeled = false
+        field.lineBreakMode = .byTruncatingTail
+        return field
+    }()
+
+    override init(frame frameRect: NSRect) {
+        super.init(frame: frameRect)
+        setupLabel()
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setupLabel()
+    }
+
     override var acceptsFirstResponder: Bool { true }
 
-    override func draw(_ dirtyRect: NSRect) {
-        let text = showRecording ? "Press keys…" : currentLabel
-        let attrs: [NSAttributedString.Key: Any] = [
-            .font: NSFont.monospacedSystemFont(ofSize: 12, weight: .medium),
-            .foregroundColor: showRecording ? NSColor.controlAccentColor : NSColor.labelColor
-        ]
-        let str = NSAttributedString(string: text, attributes: attrs)
-        let size = str.size()
-        let point = NSPoint(
-            x: (bounds.width - size.width) / 2,
-            y: (bounds.height - size.height) / 2
-        )
-        str.draw(at: point)
+    override func layout() {
+        super.layout()
+        updateLabelAppearance()
     }
 
     override func mouseDown(with event: NSEvent) {
@@ -108,4 +172,19 @@ class HotkeyNSView: NSView {
         // Resign first responder after recording
         window?.makeFirstResponder(nil)
     }
+
+    private func setupLabel() {
+        addSubview(label)
+        NSLayoutConstraint.activate([
+            label.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 6),
+            label.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -6),
+            label.centerYAnchor.constraint(equalTo: centerYAnchor)
+        ])
+        updateLabelAppearance()
+    }
+
+    private func updateLabelAppearance() {
+        label.stringValue = showRecording ? "Press keys..." : currentLabel
+        label.textColor = showRecording ? .controlAccentColor : .labelColor
+    }
 }

Downterm/CommandNotch/ContentView.swift

@@ -28,6 +28,8 @@ struct ContentView: View {
     @AppStorage(NotchSettings.Keys.hoverSpringDamping)    private var hoverSpringDamping     = NotchSettings.Defaults.hoverSpringDamping
 
     @State private var hoverTask: Task<Void, Never>?
+    @State private var resizeStartSize: CGSize?
+    @State private var resizeStartMouseLocation: CGPoint?
 
     private var hoverAnimation: Animation {
         .interactiveSpring(response: hoverSpringResponse, dampingFraction: hoverSpringDamping)
@@ -53,6 +55,11 @@ struct ContentView: View {
             .overlay(alignment: .top) {
                 Rectangle().fill(.black).frame(height: 1)
             }
+            .overlay(alignment: .bottomTrailing) {
+                if vm.notchState == .open {
+                    resizeHandle
+                }
+            }
             .shadow(
                 color: enableShadow ? Color.black.opacity(shadowOpacity) : .clear,
                 radius: enableShadow ? shadowRadius : 0
@@ -62,8 +69,8 @@ struct ContentView: View {
             .opacity(notchOpacity)
             .blur(radius: blurRadius)
             .animation(vm.notchState == .open ? vm.openAnimation : vm.closeAnimation, value: vm.notchState)
-            .animation(vm.notchState == .open ? vm.openAnimation : vm.closeAnimation, value: vm.notchSize.width)
-            .animation(vm.notchState == .open ? vm.openAnimation : vm.closeAnimation, value: vm.notchSize.height)
+            .animation(sizeAnimation, value: vm.notchSize.width)
+            .animation(sizeAnimation, value: vm.notchSize.height)
             .onHover { handleHover($0) }
             .onChange(of: vm.isCloseTransitionActive) { _, isClosing in
                 if isClosing {
@@ -74,6 +81,9 @@ struct ContentView: View {
             }
             .onDisappear {
                 hoverTask?.cancel()
+                resizeStartSize = nil
+                resizeStartMouseLocation = nil
+                vm.endInteractiveResize()
             }
             .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
             .edgesIgnoringSafeArea(.all)
@@ -104,6 +114,47 @@ struct ContentView: View {
         .background(.black)
     }
 
+    private var resizeHandle: some View {
+        ResizeHandleShape()
+            .stroke(.white.opacity(0.32), style: StrokeStyle(lineWidth: 1.2, lineCap: .round))
+            .frame(width: 16, height: 16)
+            .padding(.trailing, 8)
+            .padding(.bottom, 8)
+            .contentShape(Rectangle().inset(by: -8))
+            .gesture(resizeGesture)
+    }
+
+    private var resizeGesture: some Gesture {
+        DragGesture(minimumDistance: 0)
+            .onChanged { value in
+                if resizeStartSize == nil {
+                    resizeStartSize = vm.notchSize
+                    resizeStartMouseLocation = NSEvent.mouseLocation
+                    vm.beginInteractiveResize()
+                }
+
+                guard let startSize = resizeStartSize,
+                      let startMouseLocation = resizeStartMouseLocation else { return }
+                let currentMouseLocation = NSEvent.mouseLocation
+                vm.resizeOpenNotch(
+                    to: CGSize(
+                        width: startSize.width + ((currentMouseLocation.x - startMouseLocation.x) * 2),
+                        height: startSize.height + (startMouseLocation.y - currentMouseLocation.y)
+                    )
+                )
+            }
+            .onEnded { _ in
+                resizeStartSize = nil
+                resizeStartMouseLocation = nil
+                vm.endInteractiveResize()
+            }
+    }
+
+    private var sizeAnimation: Animation? {
+        guard !vm.isUserResizing, !vm.isPresetResizing else { return nil }
+        return vm.notchState == .open ? vm.openAnimation : vm.closeAnimation
+    }
+
     /// Open layout: VStack with toolbar row on top, terminal in the middle,
     /// tab bar at the bottom. Every section has a black background.
     private var openContent: some View {
@@ -187,3 +238,16 @@ struct ContentView: View {
         title.count <= 30 ? title : String(title.prefix(28)) + "…"
     }
 }
+
+private struct ResizeHandleShape: Shape {
+    func path(in rect: CGRect) -> Path {
+        var path = Path()
+        path.move(to: CGPoint(x: rect.maxX - 10, y: rect.maxY))
+        path.addLine(to: CGPoint(x: rect.maxX, y: rect.maxY - 10))
+        path.move(to: CGPoint(x: rect.maxX - 6, y: rect.maxY))
+        path.addLine(to: CGPoint(x: rect.maxX, y: rect.maxY - 6))
+        path.move(to: CGPoint(x: rect.maxX - 2, y: rect.maxY))
+        path.addLine(to: CGPoint(x: rect.maxX, y: rect.maxY - 2))
+        return path
+    }
+}

Downterm/CommandNotch/Managers/HotkeyManager.swift

@@ -18,6 +18,7 @@ class HotkeyManager {
     var onNextTab: (() -> Void)?
     var onPreviousTab: (() -> Void)?
     var onDetachTab: (() -> Void)?
+    var onApplySizePreset: ((TerminalSizePreset) -> Void)?
     var onSwitchToTab: ((Int) -> Void)?
 
     /// Tab-level hotkeys only fire when the notch is open.
@@ -50,6 +51,9 @@ class HotkeyManager {
     private var detachBinding: HotkeyBinding {
         binding(for: NotchSettings.Keys.hotkeyDetachTab) ?? .cmdD
     }
+    private var sizePresets: [TerminalSizePreset] {
+        TerminalSizePresetStore.load()
+    }
 
     private func binding(for key: String) -> HotkeyBinding? {
         guard let json = UserDefaults.standard.string(forKey: key) else { return nil }
@@ -211,6 +215,13 @@ class HotkeyManager {
             onDetachTab?()
             return true
         }
+        for preset in sizePresets {
+            guard let binding = preset.hotkey else { continue }
+            if binding.matches(event) {
+                onApplySizePreset?(preset)
+                return true
+            }
+        }
 
         // Cmd+1 through Cmd+9
         if event.modifierFlags.contains(.command) {

Downterm/CommandNotch/Managers/ScreenManager.swift

@@ -11,9 +11,11 @@ class ScreenManager: ObservableObject {
 
     static let shared = ScreenManager()
     private let focusRetryDelay: TimeInterval = 0.01
+    private let presetResizeFrameInterval: TimeInterval = 1.0 / 60.0
 
     private(set) var windows: [String: NotchWindow] = [:]
     private(set) var viewModels: [String: NotchViewModel] = [:]
+    private var presetResizeTimers: [String: Timer] = [:]
 
     @AppStorage(NotchSettings.Keys.showOnAllDisplays)
     private var showOnAllDisplays = NotchSettings.Defaults.showOnAllDisplays
@@ -54,6 +56,9 @@ class ScreenManager: ObservableObject {
         hk.onDetachTab   = { [weak self] in
             MainActor.assumeIsolated { self?.detachActiveTab() }
         }
+        hk.onApplySizePreset = { [weak self] preset in
+            MainActor.assumeIsolated { self?.applySizePreset(preset) }
+        }
         hk.onSwitchToTab = { index in
             MainActor.assumeIsolated { tm.switchToTab(at: index) }
         }
@@ -130,6 +135,18 @@ class ScreenManager: ObservableObject {
         }
     }
 
+    func applySizePreset(_ preset: TerminalSizePreset) {
+        guard let (screenUUID, vm) = viewModels.first(where: { $0.value.notchState == .open }) else {
+            UserDefaults.standard.set(preset.width, forKey: NotchSettings.Keys.openWidth)
+            UserDefaults.standard.set(preset.height, forKey: NotchSettings.Keys.openHeight)
+            return
+        }
+
+        let startSize = vm.notchSize
+        let targetSize = vm.setStoredOpenSize(preset.size)
+        animatePresetResize(for: screenUUID, from: startSize, to: targetSize, duration: vm.openAnimationDuration)
+    }
+
     // MARK: - Window creation
 
     func rebuildWindows() {
@@ -149,21 +166,10 @@ class ScreenManager: ObservableObject {
     private func createWindow(for screen: NSScreen) {
         let uuid = screen.displayUUID
         let vm = NotchViewModel(screenUUID: uuid)
-
-        let shadowPadding: CGFloat = 20
-        let openSize = vm.openNotchSize
-        let windowWidth  = max(openSize.width + 40, screen.frame.width * 0.5)
-        let windowHeight = openSize.height + shadowPadding
-
-        let windowRect = NSRect(
-            x: screen.frame.origin.x + (screen.frame.width - windowWidth) / 2,
-            y: screen.frame.origin.y + screen.frame.height - windowHeight,
-            width: windowWidth,
-            height: windowHeight
-        )
+        let initialContentSize = vm.openNotchSize
 
         let window = NotchWindow(
-            contentRect: windowRect,
+            contentRect: NSRect(origin: .zero, size: CGSize(width: initialContentSize.width + 40, height: initialContentSize.height + 20)),
             styleMask: [.borderless, .nonactivatingPanel, .utilityWindow],
             backing: .buffered,
             defer: false
@@ -181,19 +187,29 @@ class ScreenManager: ObservableObject {
         vm.requestClose = { [weak self] in
             self?.closeNotch(screenUUID: uuid)
         }
+        vm.requestWindowResize = { [weak self] in
+            self?.updateWindowFrame(for: uuid, centerHorizontally: true)
+        }
 
         let hostingView = NSHostingView(
             rootView: ContentView(vm: vm, terminalManager: TerminalManager.shared)
                 .preferredColorScheme(.dark)
         )
-        hostingView.frame = NSRect(origin: .zero, size: windowRect.size)
-        window.contentView = hostingView
+        let containerView = NSView(frame: NSRect(origin: .zero, size: window.frame.size))
+        containerView.autoresizesSubviews = true
+        containerView.wantsLayer = true
+        containerView.layer?.backgroundColor = NSColor.clear.cgColor
 
-        window.setFrame(windowRect, display: true)
-        window.orderFrontRegardless()
+        hostingView.frame = containerView.bounds
+        hostingView.autoresizingMask = [.width, .height]
+        containerView.addSubview(hostingView)
+        window.contentView = containerView
 
         windows[uuid] = window
         viewModels[uuid] = vm
+
+        updateWindowFrame(for: uuid, centerHorizontally: true)
+        window.orderFrontRegardless()
     }
 
     // MARK: - Repositioning
@@ -205,24 +221,144 @@ class ScreenManager: ObservableObject {
 
             vm.refreshClosedSize()
 
-            let shadowPadding: CGFloat = 20
-            let openSize = vm.openNotchSize
-            let windowWidth  = max(openSize.width + 40, screen.frame.width * 0.5)
-            let windowHeight = openSize.height + shadowPadding
+            updateWindowFrame(for: uuid, on: screen, window: window, centerHorizontally: true)
+        }
+    }
 
-            let newFrame = NSRect(
-                x: screen.frame.origin.x + (screen.frame.width - windowWidth) / 2,
+    private func updateWindowFrame(for screenUUID: String, centerHorizontally: Bool = false) {
+        guard let screen = NSScreen.screens.first(where: { $0.displayUUID == screenUUID }),
+              let window = windows[screenUUID] else { return }
+        updateWindowFrame(for: screenUUID, on: screen, window: window, centerHorizontally: centerHorizontally)
+    }
+
+    private func updateWindowFrame(
+        for screenUUID: String,
+        on screen: NSScreen,
+        window: NotchWindow,
+        centerHorizontally: Bool = false
+    ) {
+        let frame = targetWindowFrame(
+            for: screenUUID,
+            on: screen,
+            window: window,
+            centerHorizontally: centerHorizontally,
+            contentSize: nil
+        )
+        guard !window.frame.equalTo(frame) else { return }
+        window.setFrame(frame, display: false)
+    }
+
+    private func targetWindowFrame(
+        for screenUUID: String,
+        on screen: NSScreen,
+        window: NotchWindow,
+        centerHorizontally: Bool,
+        contentSize: CGSize?
+    ) -> NSRect {
+        guard let vm = viewModels[screenUUID] else { return window.frame }
+
+        let shadowPadding: CGFloat = 20
+        let openSize = contentSize ?? vm.openNotchSize
+        let windowWidth = openSize.width + 40
+        let windowHeight = openSize.height + shadowPadding
+        let centeredX = screen.frame.origin.x + (screen.frame.width - windowWidth) / 2
+
+        let x: CGFloat = centerHorizontally || vm.notchState == .closed
+            ? centeredX
+            : min(max(window.frame.minX, screen.frame.minX), screen.frame.maxX - windowWidth)
+
+        return NSRect(
+            x: x,
             y: screen.frame.origin.y + screen.frame.height - windowHeight,
             width: windowWidth,
             height: windowHeight
         )
-            window.setFrame(newFrame, display: true)
     }
+
+    private func animatePresetResize(
+        for screenUUID: String,
+        from startSize: CGSize,
+        to targetSize: CGSize,
+        duration: TimeInterval
+    ) {
+        cancelPresetResize(for: screenUUID)
+
+        guard let vm = viewModels[screenUUID] else { return }
+        guard startSize != targetSize else {
+            vm.notchSize = targetSize
+            updateWindowFrame(for: screenUUID, centerHorizontally: true)
+            return
+        }
+
+        vm.isPresetResizing = true
+        let startTime = CACurrentMediaTime()
+        let duration = max(duration, presetResizeFrameInterval)
+
+        let timer = Timer(timeInterval: presetResizeFrameInterval, repeats: true) { [weak self] timer in
+            MainActor.assumeIsolated {
+                guard let self, let vm = self.viewModels[screenUUID] else {
+                    timer.invalidate()
+                    return
+                }
+
+                let elapsed = CACurrentMediaTime() - startTime
+                let progress = min(1, elapsed / duration)
+                let easedProgress = 0.5 - (cos(.pi * progress) / 2)
+                let size = CGSize(
+                    width: startSize.width + ((targetSize.width - startSize.width) * easedProgress),
+                    height: startSize.height + ((targetSize.height - startSize.height) * easedProgress)
+                )
+
+                vm.notchSize = size
+                self.updateWindowFrame(for: screenUUID, contentSize: size, centerHorizontally: true)
+
+                if progress >= 1 {
+                    vm.notchSize = targetSize
+                    vm.isPresetResizing = false
+                    self.updateWindowFrame(for: screenUUID, contentSize: targetSize, centerHorizontally: true)
+                    self.presetResizeTimers[screenUUID] = nil
+                    timer.invalidate()
+                }
+            }
+        }
+
+        presetResizeTimers[screenUUID] = timer
+        RunLoop.main.add(timer, forMode: .common)
+        timer.fire()
+    }
+
+    private func cancelPresetResize(for screenUUID: String) {
+        presetResizeTimers[screenUUID]?.invalidate()
+        presetResizeTimers[screenUUID] = nil
+        viewModels[screenUUID]?.isPresetResizing = false
+    }
+
+    private func updateWindowFrame(
+        for screenUUID: String,
+        contentSize: CGSize,
+        centerHorizontally: Bool = false
+    ) {
+        guard let screen = NSScreen.screens.first(where: { $0.displayUUID == screenUUID }),
+              let window = windows[screenUUID] else { return }
+
+        let frame = targetWindowFrame(
+            for: screenUUID,
+            on: screen,
+            window: window,
+            centerHorizontally: centerHorizontally,
+            contentSize: contentSize
+        )
+        guard !window.frame.equalTo(frame) else { return }
+        window.setFrame(frame, display: false)
     }
 
     // MARK: - Cleanup
 
     private func cleanupAllWindows() {
+        for (_, timer) in presetResizeTimers {
+            timer.invalidate()
+        }
+        presetResizeTimers.removeAll()
         for (_, window) in windows {
             window.orderOut(nil)
             window.close()

Downterm/CommandNotch/Models/HotkeyBinding.swift

@@ -3,7 +3,7 @@ import Carbon.HIToolbox
 
 /// Serializable representation of a keyboard shortcut (modifier flags + key code).
 /// Stored in UserDefaults as a JSON string.
-struct HotkeyBinding: Codable, Equatable {
+struct HotkeyBinding: Codable, Equatable, Hashable {
     var modifiers: UInt   // NSEvent.ModifierFlags.rawValue, masked to cmd/shift/ctrl/opt
     var keyCode: UInt16
 
@@ -89,4 +89,25 @@ struct HotkeyBinding: Codable, Equatable {
     static let cmdShiftRB   = HotkeyBinding(modifiers: NSEvent.ModifierFlags([.command, .shift]).rawValue, keyCode: 30)  // ]
     static let cmdShiftLB   = HotkeyBinding(modifiers: NSEvent.ModifierFlags([.command, .shift]).rawValue, keyCode: 33)  // [
     static let cmdD         = HotkeyBinding(modifiers: NSEvent.ModifierFlags.command.rawValue, keyCode: 2)
+
+    static func cmdShiftDigit(_ digit: Int) -> HotkeyBinding? {
+        guard let keyCode = keyCode(forDigit: digit) else { return nil }
+        return HotkeyBinding(modifiers: NSEvent.ModifierFlags([.command, .shift]).rawValue, keyCode: keyCode)
+    }
+
+    static func keyCode(forDigit digit: Int) -> UInt16? {
+        switch digit {
+        case 0: return 29
+        case 1: return 18
+        case 2: return 19
+        case 3: return 20
+        case 4: return 21
+        case 5: return 23
+        case 6: return 22
+        case 7: return 26
+        case 8: return 28
+        case 9: return 25
+        default: return nil
+        }
+    }
 }

Downterm/CommandNotch/Models/NotchSettings.swift

@@ -1,4 +1,5 @@
 import Foundation
+import AppKit
 
 /// Central registry of all user-configurable notch settings.
 enum NotchSettings {
@@ -36,6 +37,7 @@ enum NotchSettings {
         static let closeSpringDamping    = "closeSpringDamping"
         static let hoverSpringResponse   = "hoverSpringResponse"
         static let hoverSpringDamping    = "hoverSpringDamping"
+        static let resizeAnimationDuration = "resizeAnimationDuration"
 
         // Behavior
         static let enableGestures        = "enableGestures"
@@ -45,6 +47,7 @@ enum NotchSettings {
         static let terminalFontSize      = "terminalFontSize"
         static let terminalShell         = "terminalShell"
         static let terminalTheme         = "terminalTheme"
+        static let terminalSizePresets   = "terminalSizePresets"
 
         // Hotkeys — each stores a HotkeyBinding JSON string
         static let hotkeyToggle          = "hotkey_toggle"
@@ -83,6 +86,7 @@ enum NotchSettings {
         static let closeSpringDamping: Double   = 1.0
         static let hoverSpringResponse: Double  = 0.38
         static let hoverSpringDamping: Double   = 0.8
+        static let resizeAnimationDuration: Double = 0.42
 
         static let enableGestures: Bool         = true
         static let gestureSensitivity: Double   = 0.5
@@ -90,6 +94,7 @@ enum NotchSettings {
         static let terminalFontSize: Double     = 13
         static let terminalShell: String        = ""
         static let terminalTheme: String        = TerminalTheme.terminalApp.rawValue
+        static let terminalSizePresets: String  = TerminalSizePresetStore.defaultPresetsJSON()
 
         // Default hotkey bindings as JSON
         static let hotkeyToggle: String      = HotkeyBinding.cmdReturn.toJSON()
@@ -129,6 +134,7 @@ enum NotchSettings {
             Keys.closeSpringDamping:    Defaults.closeSpringDamping,
             Keys.hoverSpringResponse:   Defaults.hoverSpringResponse,
             Keys.hoverSpringDamping:    Defaults.hoverSpringDamping,
+            Keys.resizeAnimationDuration: Defaults.resizeAnimationDuration,
 
             Keys.enableGestures:        Defaults.enableGestures,
             Keys.gestureSensitivity:    Defaults.gestureSensitivity,
@@ -136,6 +142,7 @@ enum NotchSettings {
             Keys.terminalFontSize:      Defaults.terminalFontSize,
             Keys.terminalShell:         Defaults.terminalShell,
             Keys.terminalTheme:         Defaults.terminalTheme,
+            Keys.terminalSizePresets:   Defaults.terminalSizePresets,
 
             Keys.hotkeyToggle:          Defaults.hotkeyToggle,
             Keys.hotkeyNewTab:          Defaults.hotkeyNewTab,
@@ -174,3 +181,82 @@ enum NonNotchHeightMode: Int, CaseIterable, Identifiable {
         }
     }
 }
+
+struct TerminalSizePreset: Codable, Equatable, Identifiable {
+    var id: UUID
+    var name: String
+    var width: Double
+    var height: Double
+    var hotkey: HotkeyBinding?
+
+    init(
+        id: UUID = UUID(),
+        name: String,
+        width: Double,
+        height: Double,
+        hotkey: HotkeyBinding? = nil
+    ) {
+        self.id = id
+        self.name = name
+        self.width = width
+        self.height = height
+        self.hotkey = hotkey
+    }
+
+    var size: CGSize {
+        CGSize(width: width, height: height)
+    }
+}
+
+enum TerminalSizePresetStore {
+    static func load() -> [TerminalSizePreset] {
+        let defaults = UserDefaults.standard
+        guard let json = defaults.string(forKey: NotchSettings.Keys.terminalSizePresets),
+              let data = json.data(using: .utf8),
+              let presets = try? JSONDecoder().decode([TerminalSizePreset].self, from: data) else {
+            return defaultPresets()
+        }
+        return presets
+    }
+
+    static func save(_ presets: [TerminalSizePreset]) {
+        guard let data = try? JSONEncoder().encode(presets),
+              let json = String(data: data, encoding: .utf8) else { return }
+        UserDefaults.standard.set(json, forKey: NotchSettings.Keys.terminalSizePresets)
+    }
+
+    static func reset() {
+        save(defaultPresets())
+    }
+
+    static func loadDefaults() -> [TerminalSizePreset] {
+        defaultPresets()
+    }
+
+    static func defaultPresetsJSON() -> String {
+        guard let data = try? JSONEncoder().encode(defaultPresets()),
+              let json = String(data: data, encoding: .utf8) else {
+            return "[]"
+        }
+        return json
+    }
+
+    static func suggestedHotkey(for presets: [TerminalSizePreset]) -> HotkeyBinding? {
+        let used = Set(presets.compactMap(\.hotkey))
+        for digit in 1...9 {
+            guard let candidate = HotkeyBinding.cmdShiftDigit(digit) else { continue }
+            if !used.contains(candidate) {
+                return candidate
+            }
+        }
+        return nil
+    }
+
+    private static func defaultPresets() -> [TerminalSizePreset] {
+        [
+            TerminalSizePreset(name: "Compact", width: 480, height: 220, hotkey: HotkeyBinding.cmdShiftDigit(1)),
+            TerminalSizePreset(name: "Default", width: 640, height: 350, hotkey: HotkeyBinding.cmdShiftDigit(2)),
+            TerminalSizePreset(name: "Large", width: 900, height: 500, hotkey: HotkeyBinding.cmdShiftDigit(3)),
+        ]
+    }
+}

Downterm/CommandNotch/Models/NotchViewModel.swift

@@ -4,6 +4,10 @@ import Combine
 /// Per-screen observable state that drives the notch UI.
 @MainActor
 class NotchViewModel: ObservableObject {
+    private static let minimumOpenWidth: CGFloat = 320
+    private static let minimumOpenHeight: CGFloat = 140
+    private static let windowHorizontalPadding: CGFloat = 40
+    private static let windowVerticalPadding: CGFloat = 20
 
     let screenUUID: String
 
@@ -13,6 +17,8 @@ class NotchViewModel: ObservableObject {
     @Published var isHovering: Bool = false
     @Published var isCloseTransitionActive: Bool = false
     @Published var suppressHoverOpenUntilHoverExit: Bool = false
+    @Published var isUserResizing: Bool = false
+    @Published var isPresetResizing: Bool = false
 
     let terminalManager = TerminalManager.shared
 
@@ -20,6 +26,7 @@ class NotchViewModel: ObservableObject {
     /// window activation so the terminal receives keyboard input.
     var requestOpen: (() -> Void)?
     var requestClose: (() -> Void)?
+    var requestWindowResize: (() -> Void)?
 
     private var cancellables = Set<AnyCancellable>()
 
@@ -30,6 +37,7 @@ class NotchViewModel: ObservableObject {
     @AppStorage(NotchSettings.Keys.openSpringDamping)   private var openSpringDamping   = NotchSettings.Defaults.openSpringDamping
     @AppStorage(NotchSettings.Keys.closeSpringResponse) private var closeSpringResponse = NotchSettings.Defaults.closeSpringResponse
     @AppStorage(NotchSettings.Keys.closeSpringDamping)  private var closeSpringDamping  = NotchSettings.Defaults.closeSpringDamping
+    @AppStorage(NotchSettings.Keys.resizeAnimationDuration) private var resizeAnimationDurationSetting = NotchSettings.Defaults.resizeAnimationDuration
 
     private var closeTransitionTask: Task<Void, Never>?
 
@@ -39,6 +47,9 @@ class NotchViewModel: ObservableObject {
     var closeAnimation: Animation {
         .spring(response: closeSpringResponse, dampingFraction: closeSpringDamping)
     }
+    var openAnimationDuration: TimeInterval {
+        max(0.05, resizeAnimationDurationSetting)
+    }
 
     init(screenUUID: String) {
         self.screenUUID = screenUUID
@@ -49,7 +60,10 @@ class NotchViewModel: ObservableObject {
     }
 
     func open() {
-        notchSize = CGSize(width: openWidth, height: openHeight)
+        let size = openNotchSize
+        openWidth = size.width
+        openHeight = size.height
+        notchSize = size
         notchState = .open
     }
 
@@ -65,7 +79,64 @@ class NotchViewModel: ObservableObject {
     }
 
     var openNotchSize: CGSize {
-        CGSize(width: openWidth, height: openHeight)
+        clampedOpenSize(CGSize(width: openWidth, height: openHeight))
+    }
+
+    func beginInteractiveResize() {
+        isUserResizing = true
+    }
+
+    func resizeOpenNotch(to proposedSize: CGSize) {
+        setOpenSize(proposedSize, notifyWindowResize: true)
+    }
+
+    func endInteractiveResize() {
+        isUserResizing = false
+    }
+
+    func applySizePreset(_ preset: TerminalSizePreset, notifyWindowResize: Bool = true) {
+        setOpenSize(preset.size, notifyWindowResize: notifyWindowResize)
+    }
+
+    @discardableResult
+    func setStoredOpenSize(_ proposedSize: CGSize) -> CGSize {
+        let clampedSize = clampedOpenSize(proposedSize)
+        openWidth = clampedSize.width
+        openHeight = clampedSize.height
+        return clampedSize
+    }
+
+    @discardableResult
+    func setOpenSize(_ proposedSize: CGSize, notifyWindowResize: Bool) -> CGSize {
+        let clampedSize = setStoredOpenSize(proposedSize)
+        if notchState == .open {
+            notchSize = clampedSize
+        }
+        if notifyWindowResize {
+            requestWindowResize?()
+        }
+        return clampedSize
+    }
+
+    private func clampedOpenSize(_ size: CGSize) -> CGSize {
+        CGSize(
+            width: size.width.clamped(to: Self.minimumOpenWidth...maximumAllowedWidth),
+            height: size.height.clamped(to: Self.minimumOpenHeight...maximumAllowedHeight)
+        )
+    }
+
+    private var maximumAllowedWidth: CGFloat {
+        guard let screen = NSScreen.screens.first(where: { $0.displayUUID == screenUUID }) ?? NSScreen.main else {
+            return Self.minimumOpenWidth
+        }
+        return max(Self.minimumOpenWidth, screen.frame.width - Self.windowHorizontalPadding)
+    }
+
+    private var maximumAllowedHeight: CGFloat {
+        guard let screen = NSScreen.screens.first(where: { $0.displayUUID == screenUUID }) ?? NSScreen.main else {
+            return Self.minimumOpenHeight
+        }
+        return max(Self.minimumOpenHeight, screen.frame.height - Self.windowVerticalPadding)
     }
 
     var closeInteractionLockDuration: TimeInterval {
@@ -102,3 +173,9 @@ class NotchViewModel: ObservableObject {
         closeTransitionTask?.cancel()
     }
 }
+
+private extension CGFloat {
+    func clamped(to range: ClosedRange<CGFloat>) -> CGFloat {
+        Swift.min(Swift.max(self, range.lowerBound), range.upperBound)
+    }
+}

Downterm/CommandNotch/Views/SettingsView.swift

@@ -1,4 +1,5 @@
 import SwiftUI
+import AppKit
 
 /// Tabbed settings panel with General, Appearance, Animation, Terminal, Hotkeys, and About.
 struct SettingsView: View {
@@ -85,6 +86,14 @@ struct GeneralSettingsView: View {
     @AppStorage(NotchSettings.Keys.openWidth)            private var openWidth             = NotchSettings.Defaults.openWidth
     @AppStorage(NotchSettings.Keys.openHeight)           private var openHeight            = NotchSettings.Defaults.openHeight
 
+    private var maxOpenWidth: Double {
+        max(openWidth, Double((NSScreen.screens.map { $0.frame.width - 40 }.max() ?? 1600).rounded()))
+    }
+
+    private var maxOpenHeight: Double {
+        max(openHeight, Double((NSScreen.screens.map { $0.frame.height - 20 }.max() ?? 900).rounded()))
+    }
+
     var body: some View {
         Form {
             Section("Display") {
@@ -146,12 +155,12 @@ struct GeneralSettingsView: View {
             Section("Open Notch Size") {
                 HStack {
                     Text("Width")
-                    Slider(value: $openWidth, in: 300...1200, step: 10)
+                    Slider(value: $openWidth, in: 320...maxOpenWidth, step: 10)
                     Text("\(Int(openWidth))pt").monospacedDigit().frame(width: 60)
                 }
                 HStack {
                     Text("Height")
-                    Slider(value: $openHeight, in: 100...600, step: 10)
+                    Slider(value: $openHeight, in: 140...maxOpenHeight, step: 10)
                     Text("\(Int(openHeight))pt").monospacedDigit().frame(width: 60)
                 }
             }
@@ -218,6 +227,7 @@ struct AnimationSettingsView: View {
     @AppStorage(NotchSettings.Keys.closeSpringDamping)   private var closeDamping   = NotchSettings.Defaults.closeSpringDamping
     @AppStorage(NotchSettings.Keys.hoverSpringResponse)  private var hoverResponse  = NotchSettings.Defaults.hoverSpringResponse
     @AppStorage(NotchSettings.Keys.hoverSpringDamping)   private var hoverDamping   = NotchSettings.Defaults.hoverSpringDamping
+    @AppStorage(NotchSettings.Keys.resizeAnimationDuration) private var resizeDuration = NotchSettings.Defaults.resizeAnimationDuration
 
     var body: some View {
         Form {
@@ -230,6 +240,9 @@ struct AnimationSettingsView: View {
             Section("Hover Animation") {
                 springControls(response: $hoverResponse, damping: $hoverDamping)
             }
+            Section("Resize Animation") {
+                durationControl(duration: $resizeDuration)
+            }
             Section {
                 Button("Reset to Defaults") {
                     openResponse  = NotchSettings.Defaults.openSpringResponse
@@ -238,6 +251,7 @@ struct AnimationSettingsView: View {
                     closeDamping  = NotchSettings.Defaults.closeSpringDamping
                     hoverResponse = NotchSettings.Defaults.hoverSpringResponse
                     hoverDamping  = NotchSettings.Defaults.hoverSpringDamping
+                    resizeDuration = NotchSettings.Defaults.resizeAnimationDuration
                 }
             }
         }
@@ -257,6 +271,15 @@ struct AnimationSettingsView: View {
             Text(String(format: "%.2f", damping.wrappedValue)).monospacedDigit().frame(width: 50)
         }
     }
+
+    @ViewBuilder
+    private func durationControl(duration: Binding<Double>) -> some View {
+        HStack {
+            Text("Duration")
+            Slider(value: duration, in: 0.05...1.5, step: 0.01)
+            Text(String(format: "%.2fs", duration.wrappedValue)).monospacedDigit().frame(width: 56)
+        }
+    }
 }
 
 // MARK: - Terminal
@@ -266,6 +289,10 @@ struct TerminalSettingsView: View {
     @AppStorage(NotchSettings.Keys.terminalFontSize) private var fontSize  = NotchSettings.Defaults.terminalFontSize
     @AppStorage(NotchSettings.Keys.terminalShell)    private var shellPath = NotchSettings.Defaults.terminalShell
     @AppStorage(NotchSettings.Keys.terminalTheme)    private var theme     = NotchSettings.Defaults.terminalTheme
+    @AppStorage(NotchSettings.Keys.openWidth)        private var openWidth = NotchSettings.Defaults.openWidth
+    @AppStorage(NotchSettings.Keys.openHeight)       private var openHeight = NotchSettings.Defaults.openHeight
+
+    @State private var sizePresets = TerminalSizePresetStore.load()
 
     var body: some View {
         Form {
@@ -298,8 +325,54 @@ struct TerminalSettingsView: View {
                     .font(.caption)
                     .foregroundStyle(.secondary)
             }
+
+            Section("Size Presets") {
+                ForEach($sizePresets) { $preset in
+                    TerminalSizePresetEditor(
+                        preset: $preset,
+                        currentOpenWidth: openWidth,
+                        currentOpenHeight: openHeight,
+                        onDelete: { deletePreset(id: preset.id) },
+                        onApply: { applyPreset(preset) }
+                    )
+                }
+
+                HStack {
+                    Button("Add Preset") {
+                        sizePresets.append(
+                            TerminalSizePreset(
+                                name: "Preset \(sizePresets.count + 1)",
+                                width: openWidth,
+                                height: openHeight,
+                                hotkey: TerminalSizePresetStore.suggestedHotkey(for: sizePresets)
+                            )
+                        )
+                    }
+
+                    Button("Reset Presets") {
+                        sizePresets = TerminalSizePresetStore.loadDefaults()
+                    }
+                }
+
+                Text("Size preset hotkeys are active when the notch is open. Default presets use ⌘⇧1, ⌘⇧2, and ⌘⇧3.")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
         }
         .formStyle(.grouped)
+        .onChange(of: sizePresets) { _, newValue in
+            TerminalSizePresetStore.save(newValue)
+        }
+    }
+
+    private func deletePreset(id: UUID) {
+        sizePresets.removeAll { $0.id == id }
+    }
+
+    private func applyPreset(_ preset: TerminalSizePreset) {
+        openWidth = preset.width
+        openHeight = preset.height
+        ScreenManager.shared.applySizePreset(preset)
     }
 }
 
@@ -329,7 +402,7 @@ struct HotkeySettingsView: View {
             }
 
             Section {
-                Text("⌘1–9 always switch to tab by number.")
+                Text("⌘1–9 always switch to tab by number. Size preset hotkeys are configured in Terminal > Size Presets.")
                     .font(.caption)
                     .foregroundStyle(.secondary)
             }
@@ -377,6 +450,52 @@ struct HotkeySettingsView: View {
     }
 }
 
+private struct TerminalSizePresetEditor: View {
+    @Binding var preset: TerminalSizePreset
+
+    let currentOpenWidth: Double
+    let currentOpenHeight: Double
+    let onDelete: () -> Void
+    let onApply: () -> Void
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            HStack {
+                TextField("Preset name", text: $preset.name)
+                    .textFieldStyle(.roundedBorder)
+                Button(role: .destructive, action: onDelete) {
+                    Image(systemName: "trash")
+                }
+                .buttonStyle(.borderless)
+            }
+
+            HStack {
+                Text("Width")
+                TextField("Width", value: $preset.width, format: .number.precision(.fractionLength(0)))
+                    .textFieldStyle(.roundedBorder)
+                    .frame(width: 90)
+
+                Text("Height")
+                TextField("Height", value: $preset.height, format: .number.precision(.fractionLength(0)))
+                    .textFieldStyle(.roundedBorder)
+                    .frame(width: 90)
+
+                Spacer()
+
+                Button("Use Current Size") {
+                    preset.width = currentOpenWidth
+                    preset.height = currentOpenHeight
+                }
+
+                Button("Apply", action: onApply)
+            }
+
+            OptionalHotkeyRecorderView(label: "Hotkey", binding: $preset.hotkey)
+        }
+        .padding(.vertical, 4)
+    }
+}
+
 // MARK: - About
 
 struct AboutSettingsView: View {