@hasna/recordings 0.1.9 → 0.1.11

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@hasna/recordings",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
-  "description": "Speech-to-text recording tool with MCP and CLI \u2014 records, transcribes, and optionally enhances text using AI",
+  "description": "Speech-to-text recording tool with MCP and CLI — records, transcribes, and optionally enhances text using AI",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -28,7 +28,7 @@
     "postinstall": "mkdir -p $HOME/.hasna/recordings/audio 2>/dev/null || true"
   },
   "dependencies": {
-    "@hasna/cloud": "^0.1.0",
+    "@hasna/cloud": "^0.1.24",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",

package/src/__tests__/enhancer.test.ts

@@ -544,6 +544,71 @@ describe("processText", () => {
   });
 });
 
+// ── systemPrompt support ──────────────────────────────────────────────────
+
+describe("systemPrompt support", () => {
+  test("processText passes systemPrompt through to enhanceText", async () => {
+    let capturedMessages: Array<{ role: string; content: string }> = [];
+    mock.module("openai", () => ({
+      default: class MockOpenAI {
+        chat = {
+          completions: {
+            create: mock((opts: { messages: Array<{ role: string; content: string }> }) => {
+              capturedMessages = opts.messages;
+              return Promise.resolve({
+                choices: [{ message: { content: "Enhanced with context" } }],
+              });
+            }),
+          },
+        };
+      },
+    }));
+
+    resetEnhancementClient();
+    const { processText: process } = await import("../lib/enhancer.js");
+    resetEnhancementClient();
+
+    await process("write an email saying thanks", config, "You are working on the Acme project");
+    expect(capturedMessages[0]!.content).toContain("Additional context:");
+    expect(capturedMessages[0]!.content).toContain("Acme project");
+
+    resetEnhancementClient();
+  });
+
+  test("processText works without systemPrompt", async () => {
+    let capturedMessages: Array<{ role: string; content: string }> = [];
+    mock.module("openai", () => ({
+      default: class MockOpenAI {
+        chat = {
+          completions: {
+            create: mock((opts: { messages: Array<{ role: string; content: string }> }) => {
+              capturedMessages = opts.messages;
+              return Promise.resolve({
+                choices: [{ message: { content: "Enhanced without context" } }],
+              });
+            }),
+          },
+        };
+      },
+    }));
+
+    resetEnhancementClient();
+    const { processText: process } = await import("../lib/enhancer.js");
+    resetEnhancementClient();
+
+    await process("write an email saying thanks", config);
+    expect(capturedMessages[0]!.content).not.toContain("Additional context:");
+
+    resetEnhancementClient();
+  });
+
+  test("processText ignores systemPrompt for raw dictation", async () => {
+    const result = await processText("Just a regular note", config, "project context");
+    expect(result.mode).toBe("raw");
+    expect(result.text).toBe("Just a regular note");
+  });
+});
+
 // ── extractInstruction (tested via needsEnhancement) ────────────────────────
 
 describe("extractInstruction behavior via needsEnhancement", () => {

package/src/cli/index.ts

@@ -148,6 +148,7 @@ program
   .description("Transcribe an existing audio file")
   .option("--no-enhance", "Skip AI enhancement")
   .option("-t, --tags <tags>", "Comma-separated tags")
+  .option("--system-prompt <prompt>", "System prompt for enhancement context")
   .action(async (file, opts) => {
     const config = loadConfig();
     ensureDataDir(config);
@@ -156,7 +157,7 @@ program
     console.log(chalk.blue("Transcribing..."));
     const transcription = await transcribeAudio(file, config);
 
-    const processed = await processText(transcription.text, config);
+    const processed = await processText(transcription.text, config, opts.systemPrompt);
     const parentOpts = program.opts();
     const tags = opts.tags ? opts.tags.split(",").map((t: string) => t.trim()) : [];
 
@@ -472,64 +473,6 @@ program
     }
   });
 
-// ── start ───────────────────────────────────────────────────────────────────
-
-program
-  .command("start")
-  .description("Launch the menu bar helper app (F5 to toggle recording)")
-  .option("--login", "Also add to Login Items so it starts automatically")
-  .action(async (opts) => {
-    const { execSync } = require("node:child_process") as typeof import("node:child_process");
-    const { join: pathJoin } = require("node:path") as typeof import("node:path");
-    const { homedir: getHome } = require("node:os") as typeof import("node:os");
-    const { existsSync: fileExists } = require("node:fs") as typeof import("node:fs");
-    const home = getHome();
-
-    const appPath = pathJoin(home, ".hasna", "recordings", "RecordingsHelper.app");
-    const oldAppPath = pathJoin(home, ".recordings", "RecordingsHelper.app");
-
-    if (!fileExists(appPath) && !fileExists(oldAppPath)) {
-      console.error(chalk.red("RecordingsHelper.app not found. Run: recordings shortcut --install"));
-      process.exit(1);
-    }
-
-    const resolvedAppPath = fileExists(appPath) ? appPath : oldAppPath;
-
-    // Kill existing instance
-    try { execSync("pkill -f RecordingsHelper", { stdio: "pipe" }); } catch { /* not running */ }
-
-    // Launch
-    execSync(`open "${resolvedAppPath}"`, { stdio: "pipe" });
-    console.log(chalk.green("Recordings helper launched — press F5 to record"));
-
-    if (opts.login) {
-      try {
-        execSync(
-          `osascript -e 'tell application "System Events" to make login item at end with properties {path:"${resolvedAppPath}", hidden:true}'`,
-          { stdio: "pipe" }
-        );
-        console.log(chalk.green("Added to Login Items — will start on boot"));
-      } catch {
-        console.log(chalk.yellow("Could not add to Login Items — add manually in System Settings > General > Login Items"));
-      }
-    }
-  });
-
-// ── stop ────────────────────────────────────────────────────────────────────
-
-program
-  .command("stop")
-  .description("Stop the menu bar helper app")
-  .action(() => {
-    const { execSync } = require("node:child_process") as typeof import("node:child_process");
-    try {
-      execSync("pkill -f RecordingsHelper", { stdio: "pipe" });
-      console.log(chalk.green("Recordings helper stopped"));
-    } catch {
-      console.log(chalk.dim("Not running"));
-    }
-  });
-
 // ── listen ───────────────────────────────────────────────────────────────────
 
 program
@@ -680,13 +623,12 @@ program
   .command("shortcut")
   .description("Set up a global keyboard shortcut for recording (macOS)")
   .option("--raycast", "Generate Raycast script command")
-  .option("--install", "Set up F5 global shortcut via macOS Services (no extra installs)")
   .option("--karabiner", "Set up Fn key via Karabiner-Elements")
   .option("--skhd", "Generate skhd hotkey config")
   .option("--hammerspoon", "Generate Hammerspoon config")
   .option("--script", "Just output the shell script path")
   .action((opts) => {
-    const { writeFileSync, mkdirSync, chmodSync, existsSync: fileExists } = require("node:fs") as typeof import("node:fs");
+    const { writeFileSync, mkdirSync, chmodSync } = require("node:fs") as typeof import("node:fs");
     const { join: pathJoin } = require("node:path") as typeof import("node:path");
     const { homedir: getHome } = require("node:os") as typeof import("node:os");
     const home = getHome();
@@ -746,72 +688,6 @@ fi
     writeFileSync(scriptPath, script, "utf-8");
     chmodSync(scriptPath, 0o755);
 
-    if (opts.install) {
-      // Install the native menu bar app — no config needed, just works with F5
-      const { execSync: exec } = require("node:child_process") as typeof import("node:child_process");
-
-      const appPath = pathJoin(home, ".hasna", "recordings", "RecordingsHelper.app");
-      const srcSwift = pathJoin(__dirname, "..", "native", "RecordingsHelper.swift");
-      const distApp = pathJoin(__dirname, "..", "RecordingsHelper.app");
-
-      // Copy pre-built app if available, otherwise compile
-      if (fileExists(pathJoin(distApp, "Contents", "MacOS", "RecordingsHelper"))) {
-        exec(`rm -rf "${appPath}" && cp -R "${distApp}" "${appPath}"`, { stdio: "pipe", shell: "/bin/bash" });
-      } else if (fileExists(srcSwift)) {
-        // Compile from source
-        console.log(chalk.blue("Compiling native helper app..."));
-        const appDir = pathJoin(home, ".hasna", "recordings", "RecordingsHelper.app", "Contents", "MacOS");
-        mkdirSync(appDir, { recursive: true });
-
-        const plistDir = pathJoin(home, ".hasna", "recordings", "RecordingsHelper.app", "Contents");
-        const plist = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0"><dict>
-<key>CFBundleExecutable</key><string>RecordingsHelper</string>
-<key>CFBundleIdentifier</key><string>com.hasna.recordings-helper</string>
-<key>CFBundleName</key><string>Recordings</string>
-<key>LSUIElement</key><true/>
-<key>NSMicrophoneUsageDescription</key><string>Recordings needs microphone access for speech transcription.</string>
-</dict></plist>`;
-        writeFileSync(pathJoin(plistDir, "Info.plist"), plist, "utf-8");
-
-        try {
-          exec(
-            `DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer xcrun swiftc -O -o "${appDir}/RecordingsHelper" "${srcSwift}" -framework Cocoa -framework Carbon`,
-            { stdio: "pipe" }
-          );
-        } catch {
-          // Fallback to default toolchain
-          exec(
-            `swiftc -O -o "${appDir}/RecordingsHelper" "${srcSwift}" -framework Cocoa -framework Carbon`,
-            { stdio: "pipe" }
-          );
-        }
-      } else {
-        console.error(chalk.red("Cannot find RecordingsHelper. Run from the project directory or rebuild."));
-        process.exit(1);
-      }
-
-      // Kill existing instance and launch
-      try { exec("pkill -f RecordingsHelper", { stdio: "pipe" }); } catch { /* not running */ }
-      exec(`open "${appPath}"`, { stdio: "pipe" });
-
-      // Add to Login Items
-      try {
-        exec(
-          `osascript -e 'tell application "System Events" to make login item at end with properties {path:"${appPath}", hidden:true}'`,
-          { stdio: "pipe" }
-        );
-      } catch { /* already exists or no permission */ }
-
-      console.log(chalk.green("\nRecordings helper installed and running!\n"));
-      console.log(`  ${chalk.yellow("F5")}     Start/stop recording`);
-      console.log(`  ${chalk.dim("🎙")}      Menu bar icon (click for options)`);
-      console.log(`  ${chalk.dim("Auto")}   Starts on login\n`);
-      console.log(chalk.dim("  Press F5 → speak → F5 → text is pasted where your cursor is."));
-      return;
-    }
-
     if (opts.karabiner) {
       const karabinerDir = pathJoin(home, ".config", "karabiner", "assets", "complex_modifications");
       mkdirSync(karabinerDir, { recursive: true });
@@ -900,9 +776,6 @@ ${scriptPath}
     console.log(chalk.cyan(`  ${scriptPath}\n`));
     console.log("Bind it to a hotkey using any of these:\n");
 
-    console.log(chalk.bold("  macOS built-in") + chalk.dim(" (no extra installs — recommended)"));
-    console.log(`    recordings shortcut --install\n`);
-
     console.log(chalk.bold("  Karabiner-Elements") + chalk.dim(" (for Fn key specifically)"));
     console.log(`    brew install --cask karabiner-elements`);
     console.log(`    recordings shortcut --karabiner\n`);
@@ -1082,7 +955,6 @@ program
   .command("remove <id>")
   .alias("rm")
   .alias("uninstall")
-  .alias("delete")
   .description("Delete a recording by ID")
   .action((id: string) => {
     const deleted = deleteRecording(id);

package/src/lib/config.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, mkdirSync, cpSync } from "fs";
+import { existsSync, readFileSync, mkdirSync, cpSync, readdirSync, statSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import type { RecordingsConfig } from "../types/index.js";
@@ -42,7 +42,7 @@ export function loadConfig(configPath?: string): RecordingsConfig {
     try {
       const raw = readFileSync(filePath, "utf-8");
       const fileConfig = JSON.parse(raw) as Partial<RecordingsConfig>;
-      Object.assign(config, fileConfig);
+      Object.assign(config, expandEnvBackedConfig(fileConfig));
     } catch {
       // Ignore invalid config files
     }
@@ -102,6 +102,19 @@ export function loadConfig(configPath?: string): RecordingsConfig {
   return config;
 }
 
+function expandEnvBackedConfig(config: Partial<RecordingsConfig>): Partial<RecordingsConfig> {
+  const expanded = { ...config };
+
+  for (const key of ["openai_api_key", "enhancement_api_key"] as const) {
+    const value = expanded[key];
+    if (typeof value === "string" && value.startsWith("$") && value.length > 1) {
+      expanded[key] = process.env[value.slice(1)] || value;
+    }
+  }
+
+  return expanded;
+}
+
 function findConfigFile(): string | null {
   // Walk up from cwd looking for .recordings/config.json
   let dir = process.cwd();
@@ -150,24 +163,51 @@ function loadSecretKey(keyName: string): string {
   const secretsPath = join(homedir(), ".secrets");
   if (!existsSync(secretsPath)) return "";
 
-  try {
-    const content = readFileSync(secretsPath, "utf-8");
-    const match = content.match(
-      new RegExp(`export\\s+${keyName}\\s*=\\s*"([^"]+)"`)
-    );
-    if (match) return match[1]!;
+  for (const candidate of listSecretFiles(secretsPath)) {
+    try {
+      const content = readFileSync(candidate, "utf-8");
+      const match = content.match(
+        new RegExp(`export\\s+${keyName}\\s*=\\s*"([^"]+)"`)
+      );
+      if (match) return match[1]!;
+
+      const match2 = content.match(
+        new RegExp(`export\\s+${keyName}\\s*=\\s*'([^']+)'`)
+      );
+      if (match2) return match2[1]!;
+
+      const match3 = content.match(new RegExp(`${keyName}\\s*=\\s*(.+)`));
+      if (match3) return match3[1]!.trim().replace(/^["']|["']$/g, "");
+    } catch {
+      // Ignore unreadable secret files
+    }
+  }
 
-    const match2 = content.match(
-      new RegExp(`export\\s+${keyName}\\s*=\\s*'([^']+)'`)
-    );
-    if (match2) return match2[1]!;
+  return "";
+}
 
-    const match3 = content.match(new RegExp(`${keyName}\\s*=\\s*(.+)`));
-    if (match3) return match3[1]!.trim().replace(/^["']|["']$/g, "");
+function listSecretFiles(path: string): string[] {
+  try {
+    const stats = statSync(path);
+    if (stats.isFile()) return [path];
+    if (!stats.isDirectory()) return [];
+
+    return readdirSync(path)
+      .sort()
+      .flatMap((entry) => {
+        const child = join(path, entry);
+        try {
+          const childStats = statSync(child);
+          if (childStats.isDirectory()) return listSecretFiles(child);
+          if (childStats.isFile() && child.endsWith(".env")) return [child];
+        } catch {
+          // Ignore entries that disappear or are unreadable
+        }
+        return [];
+      });
   } catch {
-    // Ignore
+    return [];
   }
-  return "";
 }
 
 export function ensureDataDir(config: RecordingsConfig): void {

package/src/lib/enhancer.ts

@@ -92,17 +92,12 @@ function extractInstruction(text: string, trigger: string): string {
 export async function enhanceText(
   rawText: string,
   instruction: string,
-  config: RecordingsConfig
+  config: RecordingsConfig,
+  systemPrompt?: string
 ): Promise<EnhancementResult> {
   const client = getEnhancementClient(config);
 
-  try {
-    const response = await client.chat.completions.create({
-      model: config.enhancement_model,
-      messages: [
-        {
-          role: "system",
-          content: `You are a writing assistant. The user has dictated speech that needs to be transformed into polished output.
+  const basePrompt = `You are a writing assistant. The user has dictated speech that needs to be transformed into polished output.
 
 Rules:
 - Output ONLY the enhanced/rewritten text — no explanations, no preamble
@@ -110,7 +105,17 @@ Rules:
 - Fix grammar, structure, and clarity
 - If the user is giving instructions (e.g., "write an email saying..."), produce the actual output (the email), not a description of it
 - If the user says "say it better" or similar, rewrite their preceding text to be clearer and more professional
-- Match the appropriate tone (formal for business, casual for personal)`,
+- Match the appropriate tone (formal for business, casual for personal)`;
+
+  const fullPrompt = systemPrompt ? `${basePrompt}\n\nAdditional context:\n${systemPrompt}` : basePrompt;
+
+  try {
+    const response = await client.chat.completions.create({
+      model: config.enhancement_model,
+      messages: [
+        {
+          role: "system",
+          content: fullPrompt,
         },
         {
           role: "user",
@@ -141,7 +146,8 @@ Rules:
  */
 export async function processText(
   rawText: string,
-  config: RecordingsConfig
+  config: RecordingsConfig,
+  systemPrompt?: string
 ): Promise<{
   text: string;
   mode: "raw" | "enhanced";
@@ -157,7 +163,7 @@ export async function processText(
     return { text: rawText, mode: "raw", enhancement_model: null };
   }
 
-  const result = await enhanceText(rawText, detection.instruction, config);
+  const result = await enhanceText(rawText, detection.instruction, config, systemPrompt);
 
   return {
     text: result.enhanced,

package/src/mcp/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerCloudTools } from "@hasna/cloud";
 import { z } from "zod";
 import { loadConfig, ensureDataDir } from "../lib/config.js";
 import { getDatabase, getAdapter } from "../db/database.js";
@@ -459,4 +460,5 @@ server.tool(
 );
 
 const transport = new StdioServerTransport();
+registerCloudTools(server, "recordings");
 await server.connect(transport);

package/src/native/Recordings/Recordings/FnKeyMonitor.swift

@@ -1,8 +1,8 @@
 import Cocoa
 
 /// Monitors the fn/Globe key using CGEventTap.
-/// Based on the proven pattern from CustomWispr (open-source WisprFlow alternative).
-/// User must set System Settings > Keyboard > "Press fn key to: Do Nothing" for this to work.
+/// Fn is exposed as a modifier flag, so we watch flagsChanged events and
+/// check CGEventFlags.maskSecondaryFn rather than relying on a raw bit mask.
 final class FnKeyMonitor: @unchecked Sendable {
     var onFnKeyDown: (() -> Void)?
     var onFnKeyUp: (() -> Void)?
@@ -13,7 +13,6 @@ final class FnKeyMonitor: @unchecked Sendable {
     private var fnIsDown = false
 
     private static let fnKeyCode: UInt16 = 63
-    private static let fnFlagMask: UInt64 = 0x800000
 
     /// Start monitoring. Returns true if successful.
     func start() -> Bool {
@@ -22,46 +21,54 @@ final class FnKeyMonitor: @unchecked Sendable {
             return true
         }
 
-        fputs("[FnKeyMonitor] Creating event tap...\n", stderr)
-        let eventMask: CGEventMask = (1 << CGEventType.flagsChanged.rawValue)
-
-        // passRetained so the callback reference stays alive
-        let selfPtr = Unmanaged.passRetained(self).toOpaque()
-
-        guard let tap = CGEvent.tapCreate(
-            tap: .cgSessionEventTap,
-            place: .headInsertEventTap,
-            options: .defaultTap,
-            eventsOfInterest: eventMask,
-            callback: { (proxy, type, event, refcon) -> Unmanaged<CGEvent>? in
-                guard let refcon = refcon else { return Unmanaged.passRetained(event) }
-                let monitor = Unmanaged<FnKeyMonitor>.fromOpaque(refcon).takeUnretainedValue()
-                return monitor.handleEvent(type: type, event: event)
-            },
-            userInfo: selfPtr
-        ) else {
-            Unmanaged<FnKeyMonitor>.fromOpaque(selfPtr).release()
-            return false
-        }
-
-        self.eventTap = tap
-
-        let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
-        self.runLoopSource = source
-        CFRunLoopAddSource(CFRunLoopGetCurrent(), source, .commonModes)
-        CGEvent.tapEnable(tap: tap, enable: true)
-        fputs("[FnKeyMonitor] Event tap created and enabled OK\n", stderr)
+        let eventMask: CGEventMask = 1 << CGEventType.flagsChanged.rawValue
+        let selfPtr = Unmanaged.passUnretained(self).toOpaque()
+        let candidates: [(CGEventTapLocation, CGEventTapPlacement, String)] = [
+            (.cgAnnotatedSessionEventTap, .tailAppendEventTap, "annotated-session/tail"),
+            (.cgSessionEventTap, .tailAppendEventTap, "session/tail"),
+            (.cghidEventTap, .headInsertEventTap, "hid/head"),
+        ]
+
+        for (tapLocation, tapPlacement, label) in candidates {
+            fputs("[FnKeyMonitor] Trying event tap: \(label)\n", stderr)
+
+            guard let tap = CGEvent.tapCreate(
+                tap: tapLocation,
+                place: tapPlacement,
+                options: .defaultTap,
+                eventsOfInterest: eventMask,
+                callback: { _, type, event, refcon -> Unmanaged<CGEvent>? in
+                    guard let refcon else { return Unmanaged.passRetained(event) }
+                    let monitor = Unmanaged<FnKeyMonitor>.fromOpaque(refcon).takeUnretainedValue()
+                    return monitor.handleEvent(type: type, event: event)
+                },
+                userInfo: selfPtr
+            ) else {
+                continue
+            }
 
-        // Health check: macOS silently disables taps — re-enable every 3 seconds
-        healthCheckTimer = Timer.scheduledTimer(withTimeInterval: 3.0, repeats: true) { [weak self] _ in
-            guard let self = self, let tap = self.eventTap else { return }
-            if !CGEvent.tapIsEnabled(tap: tap) {
-                fputs("[FnKeyMonitor] Tap was disabled, re-enabling\n", stderr)
-                CGEvent.tapEnable(tap: tap, enable: true)
+            eventTap = tap
+            runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
+            if let runLoopSource {
+                CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, .commonModes)
+            }
+            CGEvent.tapEnable(tap: tap, enable: true)
+            fputs("[FnKeyMonitor] Event tap ready: \(label)\n", stderr)
+
+            // Health check: macOS can silently disable taps — re-enable every 3 seconds.
+            healthCheckTimer = Timer.scheduledTimer(withTimeInterval: 3.0, repeats: true) { [weak self] _ in
+                guard let self, let tap = self.eventTap else { return }
+                if !CGEvent.tapIsEnabled(tap: tap) {
+                    fputs("[FnKeyMonitor] Tap was disabled, re-enabling\n", stderr)
+                    CGEvent.tapEnable(tap: tap, enable: true)
+                }
             }
+
+            return true
         }
 
-        return true
+        fputs("[FnKeyMonitor] Failed to create any event tap\n", stderr)
+        return false
     }
 
     func stop() {
@@ -80,7 +87,6 @@ final class FnKeyMonitor: @unchecked Sendable {
     }
 
     private func handleEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
-        // Re-enable if macOS disabled the tap
         if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {
             if let tap = eventTap {
                 CGEvent.tapEnable(tap: tap, enable: true)
@@ -88,33 +94,36 @@ final class FnKeyMonitor: @unchecked Sendable {
             return Unmanaged.passRetained(event)
         }
 
+        guard type == .flagsChanged else {
+            return Unmanaged.passRetained(event)
+        }
+
         let keyCode = UInt16(event.getIntegerValueField(.keyboardEventKeycode))
+        let fnPressed = event.flags.contains(.maskSecondaryFn)
+        let isFnTransition = keyCode == FnKeyMonitor.fnKeyCode || fnPressed || fnIsDown
 
-        // Only handle fn key (keyCode 63)
-        guard keyCode == FnKeyMonitor.fnKeyCode else {
+        guard isFnTransition else {
             return Unmanaged.passRetained(event)
         }
 
         let flags = event.flags.rawValue
-        let fnPressed = (flags & FnKeyMonitor.fnFlagMask) != 0
-
         fputs("[FnKeyMonitor] flagsChanged keyCode=\(keyCode) flags=0x\(String(flags, radix: 16)) fnPressed=\(fnPressed) fnIsDown=\(fnIsDown)\n", stderr)
 
         if fnPressed && !fnIsDown {
-            // fn just pressed
             fnIsDown = true
             fputs("[FnKeyMonitor] fn DOWN — starting recording\n", stderr)
             DispatchQueue.main.async { [weak self] in
                 self?.onFnKeyDown?()
             }
-            return nil // Swallow — prevents emoji picker / language switch
-        } else if !fnPressed && fnIsDown {
-            // fn released
+            return nil
+        }
+
+        if !fnPressed && fnIsDown {
             fnIsDown = false
             DispatchQueue.main.async { [weak self] in
                 self?.onFnKeyUp?()
             }
-            return nil // Swallow release too
+            return nil
         }
 
         return Unmanaged.passRetained(event)