Give each tab its own keyboard input source

Switching tabs now restores the input method that tab was last left in,
so a CLAUDE.md tab can stay on a CJK source while a shadow tab defaults
to English. The system input source is only touched while the panel holds
focus, so other apps keep their own input method. Per-tab sources persist
for xcode/pinned tabs and are gated behind a Settings toggle (default on).

Author: bones7456

Notchy.xcodeproj/project.pbxproj

@@ -15,6 +15,16 @@
 		31844E332F7210B20074F7B7 /* Notchy.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Notchy.app; sourceTree = BUILT_PRODUCTS_DIR; };
 /* End PBXFileReference section */
 
+/* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */
+		BD0000070000000000000007 /* Exceptions for "Notchy" folder in "Notchy" target */ = {
+			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+			membershipExceptions = (
+				Info.plist,
+			);
+			target = 31844E322F7210B20074F7B7 /* Notchy */;
+		};
+/* End PBXFileSystemSynchronizedBuildFileExceptionSet section */
+
 /* Begin PBXFileSystemSynchronizedRootGroup section */
 		31844E352F7210B20074F7B7 /* Notchy */ = {
 			isa = PBXFileSystemSynchronizedRootGroup;
@@ -26,16 +36,6 @@
 		};
 /* End PBXFileSystemSynchronizedRootGroup section */
 
-/* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */
-		BD0000070000000000000007 /* Exceptions for "Notchy" folder in "Notchy" target */ = {
-			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
-			membershipExceptions = (
-				Info.plist,
-			);
-			target = 31844E322F7210B20074F7B7 /* Notchy */;
-		};
-/* End PBXFileSystemSynchronizedBuildFileExceptionSet section */
-
 /* Begin PBXFrameworksBuildPhase section */
 		31844E302F7210B20074F7B7 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;

Notchy/InputSourceManager.swift

@@ -0,0 +1,41 @@
+import Carbon
+
+/// Thin wrapper around the Text Input Sources (TIS) API used to give each tab
+/// its own keyboard input source. macOS only tracks a single system-wide input
+/// source at a time, so "per-tab input methods" is simulated by capturing the
+/// live source when leaving a tab and re-selecting the stored one when entering.
+enum InputSourceManager {
+    /// The currently selected keyboard input source ID (e.g.
+    /// "com.apple.keylayout.ABC" or "com.apple.inputmethod.SCIM.ITABC").
+    static func currentSourceID() -> String? {
+        guard let source = TISCopyCurrentKeyboardInputSource()?.takeRetainedValue() else { return nil }
+        return sourceID(of: source)
+    }
+
+    /// Select the input source with the given ID. No-op if it can't be found
+    /// (e.g. the user removed that input source since it was recorded).
+    static func select(id: String) {
+        guard let source = source(withID: id) else { return }
+        TISSelectInputSource(source)
+    }
+
+    /// Switch to an ASCII-capable (English) keyboard layout. Uses the most
+    /// recently used ASCII source, which is what the user expects as "English".
+    static func selectASCIICapable() {
+        guard let source = TISCopyCurrentASCIICapableKeyboardInputSource()?.takeRetainedValue() else { return }
+        TISSelectInputSource(source)
+    }
+
+    private static func sourceID(of source: TISInputSource) -> String? {
+        guard let ptr = TISGetInputSourceProperty(source, kTISPropertyInputSourceID) else { return nil }
+        return Unmanaged<CFString>.fromOpaque(ptr).takeUnretainedValue() as String
+    }
+
+    private static func source(withID id: String) -> TISInputSource? {
+        let filter = [kTISPropertyInputSourceID as String: id] as CFDictionary
+        guard let list = TISCreateInputSourceList(filter, false)?.takeRetainedValue() as? [TISInputSource] else {
+            return nil
+        }
+        return list.first
+    }
+}

Notchy/SessionStore.swift

@@ -19,11 +19,25 @@ class SessionStore {
             guard let newValue = activeSessionId, newValue != oldValue else { return }
             activationHistory.removeAll { $0 == newValue }
             activationHistory.append(newValue)
+            // Per-tab input source: hand the outgoing tab's live input method off
+            // to the incoming tab. Only while the panel holds focus, so we never
+            // change the system input source out from under another app.
+            if SettingsManager.shared.perTabInputSourceEnabled && isPanelKey {
+                captureInputSource(into: oldValue)
+                applyInputSource(for: newValue)
+            }
         }
     }
     /// Stack of session IDs in the order they became active, most-recent last.
     /// On close, the previously active tab (browser-style) is restored.
     private var activationHistory: [UUID] = []
+
+    /// True while the terminal panel is the key window. Gates per-tab input
+    /// source switching so we only touch the system input source while focused.
+    private var isPanelKey = false
+    /// Input source in effect outside Notchy, captured when the panel gains
+    /// focus and restored when it loses focus, so other apps keep their IME.
+    private var externalInputSource: String?
     var isPinned: Bool = {
         if UserDefaults.standard.object(forKey: "isPinned") == nil { return true }
         return UserDefaults.standard.bool(forKey: "isPinned")
@@ -121,7 +135,7 @@ class SessionStore {
         // Normal "+" tabs are ephemeral by design — only xcode and pinned tabs survive a restart.
         let persisted = sessions
             .filter { $0.kind != .normal }
-            .map { PersistedSession(id: $0.id, projectName: $0.projectName, customName: $0.customName, projectPath: $0.projectPath, workingDirectory: $0.workingDirectory, kind: $0.kind) }
+            .map { PersistedSession(id: $0.id, projectName: $0.projectName, customName: $0.customName, projectPath: $0.projectPath, workingDirectory: $0.workingDirectory, kind: $0.kind, inputSource: $0.inputSource) }
         if let data = try? JSONEncoder().encode(persisted) {
             UserDefaults.standard.set(data, forKey: Self.sessionsKey)
         }
@@ -154,6 +168,49 @@ class SessionStore {
     /// Called when the panel gains focus — trigger a fresh Xcode scan
     func panelDidBecomeKey() {
         detectAllXcodeProjectsAsync()
+        let wasKey = isPanelKey
+        isPanelKey = true
+        // Skip when returning from an in-Notchy sheet/dialog (already key) so we
+        // don't clobber the saved external source with our own applied one.
+        guard SettingsManager.shared.perTabInputSourceEnabled, !wasKey else { return }
+        externalInputSource = InputSourceManager.currentSourceID()
+        applyInputSource(for: activeSessionId)
+    }
+
+    /// Called when the panel truly loses focus to another app (not an in-Notchy
+    /// sheet). Remembers the active tab's input source and restores the external
+    /// app's input source so we never leave another app stuck in English.
+    func panelDidResignKey() {
+        isPanelKey = false
+        guard SettingsManager.shared.perTabInputSourceEnabled else { return }
+        captureInputSource(into: activeSessionId)
+        if let external = externalInputSource {
+            InputSourceManager.select(id: external)
+            externalInputSource = nil
+        }
+    }
+
+    /// Save the live system input source into the given tab's record.
+    private func captureInputSource(into sessionID: UUID?) {
+        guard let id = sessionID,
+              let index = sessions.firstIndex(where: { $0.id == id }),
+              let current = InputSourceManager.currentSourceID(),
+              sessions[index].inputSource != current else { return }
+        sessions[index].inputSource = current
+        persistSessions()
+    }
+
+    /// Switch the system input source to match the given tab. A never-visited
+    /// "+" tab defaults to English; xcode/pinned tabs inherit the current source
+    /// on first visit (and remember whatever they're left in thereafter).
+    private func applyInputSource(for sessionID: UUID?) {
+        guard let id = sessionID,
+              let session = sessions.first(where: { $0.id == id }) else { return }
+        if let saved = session.inputSource {
+            InputSourceManager.select(id: saved)
+        } else if session.kind == .normal {
+            InputSourceManager.selectASCIICapable()
+        }
     }
 
     /// Scans for all open Xcode projects — adds new ones, updates active set.

Notchy/SettingsManager.swift

@@ -82,6 +82,12 @@ class SettingsManager {
         didSet { UserDefaults.standard.set(terminalLigaturesEnabled, forKey: "terminalLigaturesEnabled") }
     }
 
+    /// Give each tab its own keyboard input source: switching tabs restores the
+    /// input method that tab was last left in; new "+" tabs default to English.
+    var perTabInputSourceEnabled: Bool {
+        didSet { UserDefaults.standard.set(perTabInputSourceEnabled, forKey: "perTabInputSourceEnabled") }
+    }
+
     static let minBufferSize = 500
     static let maxBufferSize = 50000
     static let defaultBufferSize = 1000
@@ -114,6 +120,7 @@ class SettingsManager {
         if defaults.object(forKey: "terminalBufferSize") == nil { defaults.set(Self.defaultBufferSize, forKey: "terminalBufferSize") }
         if defaults.object(forKey: "terminalFontWeight") == nil { defaults.set(TerminalFontWeight.regular.rawValue, forKey: "terminalFontWeight") }
         if defaults.object(forKey: "terminalLigaturesEnabled") == nil { defaults.set(true, forKey: "terminalLigaturesEnabled") }
+        if defaults.object(forKey: "perTabInputSourceEnabled") == nil { defaults.set(true, forKey: "perTabInputSourceEnabled") }
 
         showNotch = defaults.bool(forKey: "replaceNotch")
         soundsEnabled = defaults.bool(forKey: "soundsEnabled")
@@ -130,6 +137,7 @@ class SettingsManager {
         terminalFontSize = storedFontSize > 0 ? CGFloat(storedFontSize) : 13
         terminalFontWeight = TerminalFontWeight(rawValue: defaults.string(forKey: "terminalFontWeight") ?? "") ?? .regular
         terminalLigaturesEnabled = defaults.bool(forKey: "terminalLigaturesEnabled")
+        perTabInputSourceEnabled = defaults.bool(forKey: "perTabInputSourceEnabled")
         let storedBufferSize = defaults.integer(forKey: "terminalBufferSize")
         terminalBufferSize = storedBufferSize > 0
             ? max(Self.minBufferSize, min(Self.maxBufferSize, storedBufferSize))

Notchy/SettingsWindow.swift

@@ -113,6 +113,12 @@ struct GeneralTab: View {
                         .font(.caption)
                         .foregroundStyle(.secondary)
                 }
+                Toggle(isOn: $settings.perTabInputSourceEnabled) {
+                    Text("Per-tab input source")
+                    Text("Each tab remembers its own keyboard input method; new \"+\" tabs default to English")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
                 BufferSizeRow()
             }
         }

Notchy/TerminalPanel.swift

@@ -299,8 +299,13 @@ class TerminalPanel: NSPanel, NSWindowDelegate {
     }
 
     @objc func windowDidResignKey(_ notification: Notification) {
-        if !sessionStore.isPinned && !sessionStore.isShowingDialog && attachedSheet == nil && childWindows?.isEmpty ?? true {
-            hidePanel()
+        // Focus moving to an in-Notchy sheet/dialog isn't really "leaving".
+        let focusStillInNotchy = sessionStore.isShowingDialog || attachedSheet != nil || !(childWindows?.isEmpty ?? true)
+        if !focusStillInNotchy {
+            sessionStore.panelDidResignKey()
+            if !sessionStore.isPinned {
+                hidePanel()
+            }
         }
         updateOpacity()
     }

Notchy/TerminalSession.swift

@@ -86,6 +86,9 @@ struct TerminalSession: Identifiable {
     /// When the session most recently entered the .working state
     var workingStartedAt: Date?
     var kind: TabKind
+    /// TIS input source ID this tab was last left in, restored on re-select.
+    /// nil until the tab has been visited (see SessionStore input-source logic).
+    var inputSource: String?
 
     var displayName: String { customName ?? projectName }
 
@@ -117,6 +120,7 @@ struct TerminalSession: Identifiable {
         self.createdAt = Date()
         // Migration: older persisted records have no kind — infer from projectPath
         self.kind = persisted.kind ?? (persisted.projectPath != nil ? .xcode : .normal)
+        self.inputSource = persisted.inputSource
     }
 }
 
@@ -128,4 +132,5 @@ struct PersistedSession: Codable {
     let projectPath: String?
     let workingDirectory: String
     let kind: TabKind?
+    let inputSource: String?
 }

README.md

@@ -19,6 +19,7 @@ A macOS menu bar app that puts Claude Code or Codex right in your MacBook's notc
 - **Ligature toggle** — Settings → General → Terminal → Ligatures switches off OpenType `calt` and `liga` substitutions, so `===`, `=>`, `!=` etc. render as plain characters instead of combined glyphs
 - **Force-click to look up** — deep-press a word in the terminal to pop up its system dictionary definition, just like Safari's Look Up; toggle via Settings → General → Terminal → Look up on force click
 - **Right-click menu** — right-click in the terminal for Copy / Paste / Select All, look up or web-search the selection (or the word under the cursor), open a URL under the cursor, and clear the screen
+- **Per-tab input source** — each tab remembers its own keyboard input method, so a CLAUDE.md tab can stay on a CJK input source while a shadow tab defaults to English; switches automatically as you change tabs and leaves other apps' input source untouched. Toggle via Settings → General → Terminal → Per-tab input source
 - **Adjustable scrollback** — set the terminal history buffer in Settings → General → Terminal (default 1,000 lines, up to 50,000)
 - **Live status in the notch** — animated pill shows whether the agent is working, waiting, or done
 - **Git checkpoints** — Cmd+S to snapshot your project before the agent makes changes