Skip to content

YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context

fix(overlay): add Wispr-style hiding controls (#6317)

Louis Beaumont362bf60d45c7
diff --git a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx
index 778048ed7..b22305528 100644
--- a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx
+++ b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx
@@ -20,6 +20,7 @@ const mocks = vi.hoisted(() => ({
storeGet: vi.fn(),
storeSet: vi.fn(),
hideShortcutReminder: vi.fn(),
+ snoozeShortcutReminderForHour: vi.fn(),
showWindow: vi.fn(),
setSize: vi.fn(),
setPosition: vi.fn(),
@@ -118,6 +119,7 @@ vi.mock("@/lib/utils/tauri", () => ({
overlayRestartRecording: vi.fn(),
overlayDismissIncident: vi.fn(),
hideShortcutReminder: mocks.hideShortcutReminder,
+ snoozeShortcutReminderForHour: mocks.snoozeShortcutReminderForHour,
showWindow: mocks.showWindow,
setShortcutOverlayAnchor: mocks.setShortcutOverlayAnchor,
},
@@ -155,6 +157,8 @@ describe("recording health hover detail", () => {
mocks.stopMeeting.mockReset();
mocks.storeSet.mockReset();
mocks.hideShortcutReminder.mockReset();
+ mocks.snoozeShortcutReminderForHour.mockReset();
+ mocks.snoozeShortcutReminderForHour.mockResolvedValue({ status: "ok", data: null });
mocks.showWindow.mockReset();
mocks.setSize.mockReset();
mocks.setPosition.mockReset();
@@ -306,7 +310,7 @@ describe("recording health hover detail", () => {
expect(meetingDot.className).toContain("pointer-events-none");
});
- it("cannot be hidden from the gear — it opens Display settings instead", async () => {
+ it("offers Wispr-style one-hour hiding and a path to Display settings", async () => {
mocks.getRecordingHealthState.mockResolvedValue("normal");
mocks.storeGet.mockResolvedValue({});
@@ -315,12 +319,16 @@ describe("recording health hover detail", () => {
fireEvent.mouseEnter(await screen.findByTestId("shortcut-reminder-root"));
fireEvent.click(await screen.findByTitle("Overlay settings"));
- // The gear never hides the pill. Even when `overlay-hiding-control` grants
- // the capability back, the switch lives in Display settings, not here.
- expect(screen.queryByTitle("Hide for today")).toBeNull();
- expect(screen.queryByTitle("Hide for a week")).toBeNull();
- expect(mocks.hideShortcutReminder).not.toHaveBeenCalled();
- expect(mocks.storeSet).not.toHaveBeenCalled();
+ expect(screen.getByRole("menu", { name: "Shortcut reminder options" })).toBeVisible();
+ fireEvent.click(screen.getByTitle("Hide for 1 hour"));
+
+ await waitFor(() =>
+ expect(mocks.snoozeShortcutReminderForHour).toHaveBeenCalledTimes(1),
+ );
+
+ fireEvent.mouseEnter(screen.getByTestId("shortcut-reminder-root"));
+ fireEvent.click(screen.getByTitle("Overlay settings"));
+ fireEvent.click(screen.getByTitle("Open overlay settings"));
expect(mocks.showWindow).toHaveBeenCalledWith({ Home: { page: "display" } });
});
diff --git a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx
index 8a281843b..c1be3bc07 100644
--- a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx
+++ b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx
@@ -63,6 +63,7 @@ const DEFAULT_SHORTCUTS = {
const COLLAPSED_SIZE = { width: 22, height: 16 };
const EXPANDED_SIZE = { width: 160, height: 62 };
+const SETTINGS_MENU_SIZE = { width: 164, height: 96 };
const INCIDENT_SIZE = { width: 160, height: 40 };
const MEETING_SIZE = { width: 280, height: 80 };
@@ -85,6 +86,7 @@ export default function ShortcutReminderPage() {
const [hoverMeetingId, setHoverMeetingId] = useState<number | null>(null);
const [pinnedMeetingId, setPinnedMeetingId] = useState<number | null>(null);
const [expanded, setExpanded] = useState(false);
+ const [settingsOpen, setSettingsOpen] = useState(false);
const [hoveredControl, setHoveredControl] = useState<string | null>(null);
const [overlayScale, setOverlayScale] = useState(1);
const [anchor, setAnchor] = useState<OverlayAnchor>(DEFAULT_OVERLAY_ANCHOR);
@@ -354,6 +356,8 @@ export default function ShortcutReminderPage() {
resizeOverlay(INCIDENT_SIZE);
} else if (meetingOverlay.active && meetingCardOpen) {
resizeOverlay(MEETING_SIZE);
+ } else if (settingsOpen) {
+ resizeOverlay(SETTINGS_MENU_SIZE);
} else if (expanded) {
resizeOverlay(EXPANDED_SIZE);
} else {
@@ -366,6 +370,7 @@ export default function ShortcutReminderPage() {
meetingCardOpen,
meetingOverlay.active,
resizeOverlay,
+ settingsOpen,
]);
const handleRestartRecording = useCallback(async (e: React.MouseEvent) => {
@@ -409,10 +414,29 @@ export default function ShortcutReminderPage() {
const handleOpenSettings = useCallback((e: React.MouseEvent) => {
e.preventDefault();
e.stopPropagation();
+ setSettingsOpen(false);
posthog.capture("shortcut_reminder_overlay_settings_clicked");
void commands.showWindow({ Home: { page: "display" } });
}, []);
+ const handleHourSnooze = useCallback(async (e: React.MouseEvent) => {
+ e.preventDefault();
+ e.stopPropagation();
+ // Close immediately so a slow encrypted-store write cannot close a menu
+ // the user reopened while the reminder is still animating away.
+ setSettingsOpen(false);
+ try {
+ const result = await commands.snoozeShortcutReminderForHour();
+ if (result.status === "error") throw new Error(result.error);
+ posthog.capture("shortcut_reminder_dismissed", {
+ dismiss_scope: "hour",
+ snooze_hours: 1,
+ });
+ } catch (error) {
+ console.error("Failed to snooze shortcut reminder:", error);
+ }
+ }, []);
+
// Size tokens are scaled inline instead of via CSS `transform: scale()` so
// we avoid subpixel-rounding clipping at non-integer scales (e.g. 1.5×)
// and don't double-compensate the window — Rust already sizes the Tauri
@@ -761,6 +785,7 @@ export default function ShortcutReminderPage() {
}}
onMouseLeave={() => {
setExpanded(false);
+ setSettingsOpen(false);
setHoveredControl(null);
}}
>
@@ -834,20 +859,55 @@ export default function ShortcutReminderPage() {
onMouseEnter={() => setHoveredControl("settings")}
onMouseDown={(e) => e.stopPropagation()}
onPointerDown={(e) => e.stopPropagation()}
- onClick={handleOpenSettings}
+ onClick={(e) => {
+ e.stopPropagation();
+ setSettingsOpen((open) => !open);
+ }}
>
<Settings style={{ width: `${12 * overlayScale}px`, height: `${12 * overlayScale}px` }} />
</button>
</div>
- {/* The label row only exists while a control is hovered. The native panel
+ {settingsOpen ? (
+ <div
+ role="menu"
+ aria-label="Shortcut reminder options"
+ className="flex w-full min-h-0 flex-1 flex-col overflow-hidden border border-white/40 font-mono text-white/85"
+ style={{
+ marginTop: dockAbove ? `${4 * overlayScale}px` : 0,
+ marginBottom: dockAbove ? 0 : `${4 * overlayScale}px`,
+ background: "rgba(0, 0, 0, 0.96)",
+ borderRadius: `${4 * overlayScale}px`,
+ fontSize: `${fontPx}px`,
+ }}
+ >
+ <button
+ role="menuitem"
+ className="flex-1 px-2 text-left hover:bg-white/15"
+ title="Hide for 1 hour"
+ onClick={(e) => void handleHourSnooze(e)}
+ >
+ hide for 1 hour
+ </button>
+ <div className="mx-2 bg-white/20" style={{ height: "1px" }} />
+ <button
+ role="menuitem"
+ className="flex-1 px-2 text-left hover:bg-white/15"
+ title="Open overlay settings"
+ onClick={handleOpenSettings}
+ >
+ settings…
+ </button>
+ </div>
+ ) : (
+ /* The label row only exists while a control is hovered. The native panel
keeps this area transparent (`Color.clear`) and floats the label under
the hovered icon; painting it unconditionally left an empty black bar
hanging under the dock whenever the pointer sat between icons. The
- reserved height stays either way so the dock never shifts. */}
- <div
- className="flex w-full min-h-0 flex-1 items-center justify-center overflow-hidden font-mono text-white/75"
- style={{
+ reserved height stays either way so the dock never shifts. */
+ <div
+ className="flex w-full min-h-0 flex-1 items-center justify-center overflow-hidden font-mono text-white/75"
+ style={{
maxHeight: `${26 * overlayScale}px`,
// The gap belongs between the two rows, and `column-reverse` does not
// flip which physical side a margin lands on. Keeping it on `top`
@@ -859,15 +919,16 @@ export default function ShortcutReminderPage() {
border: `1px solid ${disclosure ? "rgba(255, 255, 255, 0.25)" : "transparent"}`,
borderRadius: `${4 * overlayScale}px`,
fontSize: `${fontPx}px`,
- }}
- >
- {disclosure ? (
- <span className="truncate px-1">
- {disclosure[0]}
- {disclosure[1] ? ` ${disclosure[1]}` : ""}
- </span>
- ) : null}
- </div>
+ }}
+ >
+ {disclosure ? (
+ <span className="truncate px-1">
+ {disclosure[0]}
+ {disclosure[1] ? ` ${disclosure[1]}` : ""}
+ </span>
+ ) : null}
+ </div>
+ )}
</div>
);
}
diff --git a/apps/screenpipe-app-tauri/components/settings/display-section.tsx b/apps/screenpipe-app-tauri/components/settings/display-section.tsx
index a97d22fab..1bdf629c3 100644
--- a/apps/screenpipe-app-tauri/components/settings/display-section.tsx
+++ b/apps/screenpipe-app-tauri/components/settings/display-section.tsx
@@ -556,9 +556,6 @@ export function DisplaySection() {
opens the timeline — hide the whole section when the timeline is off. */}
{!(settings?.disableTimeline ?? false) && (
<>
- {/* The overlay ships unhideable because it carries recording health,
- live meeting state and meeting alerts. `overlay-hiding-control`
- hands the switch back remotely if that proves too strict. */}
<Card className="border-border bg-card">
<CardContent className="px-3 py-2.5">
<div className="flex items-center justify-between">
@@ -566,32 +563,30 @@ export function DisplaySection() {
<Monitor className="h-4 w-4 text-muted-foreground shrink-0" />
<div>
<h3 className="text-sm font-medium text-foreground">Shortcut Reminder</h3>
- {/* Only the "always on screen" claim depends on the flag.
- The drag hint is true either way and is the only place
- pinning is discoverable, so it stays in both. */}
<p className="text-xs text-muted-foreground">
- {settings?.allowHidingShortcutOverlay
- ? "Carries recording health, live meeting state and meeting alerts. Drag it to pin it to any corner or edge."
- : "Always on screen. It carries recording health, live meeting state and meeting alerts. Drag it to pin it to any corner or edge."}
+ Show the floating shortcut bar. Recording problems can still surface temporarily.
</p>
</div>
</div>
- {settings?.allowHidingShortcutOverlay && (
- <Switch
- id="shortcut-overlay"
- checked={settings?.showShortcutOverlay ?? true}
- onCheckedChange={async (checked) => {
- handleSettingsChange({ showShortcutOverlay: checked });
- try {
- if (checked) {
- await commands.showShortcutReminder(settings.showScreenpipeShortcut);
- } else {
- await commands.hideShortcutReminder();
- }
- } catch (e) {}
- }}
- />
- )}
+ <Switch
+ id="shortcut-overlay"
+ checked={settings?.showShortcutOverlay ?? true}
+ onCheckedChange={async (checked) => {
+ await updateSettings({
+ showShortcutOverlay: checked,
+ shortcutOverlaySnoozedUntil: null,
+ });
+ try {
+ if (checked) {
+ await commands.showShortcutReminder(settings.showScreenpipeShortcut);
+ } else {
+ await commands.hideShortcutReminder();
+ }
+ } catch (error) {
+ console.warn("failed to update shortcut reminder visibility", error);
+ }
+ }}
+ />
</div>
</CardContent>
</Card>
diff --git a/apps/screenpipe-app-tauri/e2e/specs/windows-user-journey.spec.ts b/apps/screenpipe-app-tauri/e2e/specs/windows-user-journey.spec.ts
index 479e71d9b..79f211c28 100644
--- a/apps/screenpipe-app-tauri/e2e/specs/windows-user-journey.spec.ts
+++ b/apps/screenpipe-app-tauri/e2e/specs/windows-user-journey.spec.ts
@@ -647,7 +647,7 @@ describe("Windows user journey", function () {
expect(existsSync(shortcutsScreenshot)).toBe(true);
});
- it("keeps the shortcut reminder overlay on screen and drives its dock actions", async function () {
+ it("lets users control the shortcut reminder and drives its dock actions", async function () {
if (!isWindows) this.skip();
await openHomeWindow();
@@ -660,10 +660,8 @@ describe("Windows user journey", function () {
await displayNav.waitForDisplayed({ timeout: t(15_000) });
await displayNav.click();
- // The overlay carries recording health, live meeting state and meeting
- // alerts, so it ships unhideable and Display offers only a size. The
- // `overlay-hiding-control` remote flag can restore the switch, but it is
- // off by default and E2E never initializes PostHog.
+ // Like Wispr Flow, the persistent choice lives in Settings while the
+ // floating menu owns the temporary one-hour snooze.
await waitForBodyText(
(bodyText) =>
bodyText.includes("theme, windows, and overlay appearance") &&
@@ -671,7 +669,7 @@ describe("Windows user journey", function () {
bodyText.includes("overlay size"),
"Display settings did not show the shortcut reminder controls",
);
- expect(await $("#shortcut-overlay").isExisting()).toBe(false);
+ expect(await $("#shortcut-overlay").isExisting()).toBe(true);
try {
await expectShortcutReminderVisible(true, t(20_000));
@@ -790,10 +788,12 @@ describe("Windows user journey", function () {
await overlaySettingsButton.waitForDisplayed({ timeout: t(10_000) });
await overlaySettingsButton.click();
- // The gear opens Display settings; it must not offer to hide the pill,
- // and the pill must still be on screen afterwards.
- expect(await $('button[title="Hide for today"]').isExisting()).toBe(false);
- expect(await $('button[title="Hide for a week"]').isExisting()).toBe(false);
+ // Match Wispr Flow's progressive disclosure: the floating bar offers a
+ // one-hour snooze and links to the persistent control in Display.
+ const hideForHourButton = await $('button[title="Hide for 1 hour"]');
+ await hideForHourButton.waitForDisplayed({ timeout: t(10_000) });
+ const persistentSettingsButton = await $('button[title="Open overlay settings"]');
+ await persistentSettingsButton.waitForDisplayed({ timeout: t(10_000) });
await expectShortcutReminderVisible(true, t(20_000));
} finally {
if ((await browser.getWindowHandles()).includes("home")) {
diff --git a/apps/screenpipe-app-tauri/lib/desktop-remote-control.test.ts b/apps/screenpipe-app-tauri/lib/desktop-remote-control.test.ts
index bec06e593..c18a250ee 100644
--- a/apps/screenpipe-app-tauri/lib/desktop-remote-control.test.ts
+++ b/apps/screenpipe-app-tauri/lib/desktop-remote-control.test.ts
@@ -340,8 +340,8 @@ describe("desktop remote control", () => {
).toEqual([]);
});
- it("ships the overlay unhideable and never seeds a local opt-in", () => {
- // Shipped: the capability is off, so the Display toggle stays absent.
+ it("ships the rollout capability disabled and never seeds a local opt-in", () => {
+ // The user-facing visibility choice is independent of this legacy rollout.
expect(
resolveBooleanRemoteControlValue(
"overlayHiding",
@@ -350,7 +350,7 @@ describe("desktop remote control", () => {
),
).toBe(false);
- // Remote grant: the toggle comes back without a release.
+ // Managed installs can still grant the legacy capability remotely.
expect(
resolveBooleanRemoteControlValue("overlayHiding", null, {
defaultEnabled: true,
@@ -358,8 +358,7 @@ describe("desktop remote control", () => {
}),
).toBe(true);
- // Nothing lets a user grant themselves the capability, so the preference
- // must stay null forever — a seeded value would make the flag a no-op.
+ // The capability remains inherited rather than becoming sticky.
expect(
normalizeDesktopRemotePreferences({
allowHidingShortcutOverlay: true,
diff --git a/apps/screenpipe-app-tauri/lib/desktop-remote-control.ts b/apps/screenpipe-app-tauri/lib/desktop-remote-control.ts
index ca2bb7c67..c765bccdc 100644
--- a/apps/screenpipe-app-tauri/lib/desktop-remote-control.ts
+++ b/apps/screenpipe-app-tauri/lib/desktop-remote-control.ts
@@ -43,10 +43,8 @@ export const BOOLEAN_REMOTE_CONTROL_DEFINITIONS = {
settingKey: "enableSidebarCustomization",
shippedDefault: false,
},
- // Whether the user is allowed to hide the shortcut overlay at all. The
- // overlay carries recording health, live meeting state and meeting alerts,
- // so it ships unhideable; this is the remote escape hatch that gives the
- // Display toggle back if that turns out to be too strict.
+ // Compatibility control retained for managed installs. The consumer UI's
+ // visibility choice is independent from this rollout capability.
overlayHiding: {
flagKey: "overlay-hiding-control",
settingKey: "allowHidingShortcutOverlay",
diff --git a/apps/screenpipe-app-tauri/lib/hooks/use-settings.tsx b/apps/screenpipe-app-tauri/lib/hooks/use-settings.tsx
index e29a0d1e4..2f225f48e 100644
--- a/apps/screenpipe-app-tauri/lib/hooks/use-settings.tsx
+++ b/apps/screenpipe-app-tauri/lib/hooks/use-settings.tsx
@@ -783,6 +783,7 @@ let DEFAULT_SETTINGS: Settings = {
enableSidebarCustomization: false,
allowHidingShortcutOverlay: false,
showShortcutOverlay: true,
+ shortcutOverlaySnoozedUntil: null,
sidebarNavLayout: { ...DEFAULT_SIDEBAR_NAV_LAYOUT },
ignoreIncognitoWindows: true,
enhancedIncognitoDetection: false,
diff --git a/apps/screenpipe-app-tauri/lib/utils/tauri.ts b/apps/screenpipe-app-tauri/lib/utils/tauri.ts
index 95971ff7d..e30d0fad7 100644
--- a/apps/screenpipe-app-tauri/lib/utils/tauri.ts
+++ b/apps/screenpipe-app-tauri/lib/utils/tauri.ts
@@ -2445,6 +2445,14 @@ async showWindowActivated(window: ShowRewindWindow) : Promise<Result<null, strin
else return { status: "error", error: e as any };
}
},
+async snoozeShortcutReminderForHour() : Promise<Result<null, string>> {
+ try {
+ return { status: "ok", data: await TAURI_INVOKE("snooze_shortcut_reminder_for_hour") };
+} catch (e) {
+ if(e instanceof Error) throw e;
+ else return { status: "error", error: e as any };
+}
+},
/**
* Start the server (if not running) and capture.
* This is the main entry point called by the frontend.
@@ -3421,10 +3429,10 @@ captureOnClipboard?: boolean | null;
/**
* Override `UiRecorderConfig::capture_scroll`.
* None = engine default (false). When true, scroll wheel events are
- * recorded into `ui_events` so the `ScrollBurstTracker` can fire a
- * `ScrollStop` trigger at burst-end and link the last scroll row to
- * the resulting frame. Off by default — wheel ticks fire at ~60Hz
- * and inflate the table fast.
+ * recorded into `ui_events` so the `ScrollBurstTracker` can retain every
+ * correlation ID, fire a `ScrollStop` trigger at burst-end, and link every
+ * persisted scroll row in the settled burst to the resulting frame. Off by
+ * default — wheel ticks fire at ~60Hz and inflate the table fast.
*/
captureScroll?: boolean | null;
/**
@@ -3712,14 +3720,17 @@ listenOnLan?: boolean }) &
*/
shortcutOverlaySize?: string;
/**
- * The user's choice, honored only while `allow_hiding_shortcut_overlay`
- * is on. The overlay ships unhideable, so this is inert by default.
+ * The user's persistent choice for the shortcut reminder. Recording-health
+ * incidents may still reveal their own temporary recovery surface.
*/
showShortcutOverlay?: boolean;
/**
- * Remote-controlled capability (`overlay-hiding-control`), written by the
- * desktop remote-control registry. False ships; flipping the flag on gives
- * the Display toggle back without a release.
+ * Unix timestamp until which the user asked to hide the shortcut reminder.
+ */
+shortcutOverlaySnoozedUntil?: number | null;
+/**
+ * Compatibility capability written by the desktop remote-control registry.
+ * Consumer visibility is controlled by `show_shortcut_overlay` above.
*/
allowHidingShortcutOverlay?: boolean;
/**
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/commands.rs b/apps/screenpipe-app-tauri/src-tauri/src/commands.rs
index 0bcb1d962..7cab0168a 100644
--- a/apps/screenpipe-app-tauri/src-tauri/src/commands.rs
+++ b/apps/screenpipe-app-tauri/src-tauri/src/commands.rs
@@ -56,8 +56,8 @@ mod tests {
merge_enterprise_file_configs, persist_enterprise_device_config,
persist_recovered_enterprise_device_config, read_enterprise_config_from_path,
notification_belongs_to_overlay, recovery_anchor_license_key, save_enterprise_team_config,
- scan_chat_entries_by_mtime, shortcut_overlay_hidden_by_choice, EnterpriseFileConfig,
- RecoveredEnterpriseDeviceConfig,
+ scan_chat_entries_by_mtime, shortcut_overlay_hidden_by_choice,
+ should_resume_snoozed_overlay, EnterpriseFileConfig, RecoveredEnterpriseDeviceConfig,
};
/// `get_local_api_config` must never await the server mutex.
@@ -113,15 +113,20 @@ mod tests {
assert_eq!(config["port"], 3030);
}
- /// The overlay ships unhideable. A stored `showShortcutOverlay: false` —
- /// whether left over from before this shipped or set while the remote
- /// capability was on — must stay inert until the flag grants it back.
#[test]
- fn a_stored_hide_choice_only_counts_once_remote_policy_allows_it() {
- assert!(!shortcut_overlay_hidden_by_choice(false, false));
- assert!(!shortcut_overlay_hidden_by_choice(false, true));
- assert!(shortcut_overlay_hidden_by_choice(true, false));
- assert!(!shortcut_overlay_hidden_by_choice(true, true));
+ fn saved_choice_and_active_snooze_hide_the_shortcut_overlay() {
+ assert!(shortcut_overlay_hidden_by_choice(false, None, 100));
+ assert!(shortcut_overlay_hidden_by_choice(true, Some(101), 100));
+ assert!(!shortcut_overlay_hidden_by_choice(true, Some(100), 100));
+ assert!(!shortcut_overlay_hidden_by_choice(true, None, 100));
+ }
+
+ #[test]
+ fn only_the_matching_expired_snooze_may_restore_the_overlay() {
+ assert!(should_resume_snoozed_overlay(true, Some(100), 100, 100));
+ assert!(!should_resume_snoozed_overlay(false, Some(100), 100, 100));
+ assert!(!should_resume_snoozed_overlay(true, Some(200), 100, 100));
+ assert!(!should_resume_snoozed_overlay(true, Some(100), 100, 99));
}
#[test]
@@ -2886,42 +2891,128 @@ fn shortcut_reminder_payload(
map
}
-/// Whether a stored "keep the overlay hidden" choice may be honored at all.
-/// The overlay is the app's only always-on surface — it carries recording
-/// health, live meeting state and meeting notifications — so it ships
-/// unhideable and a stale stored `false` stays inert. `overlay-hiding-control`
-/// (see `lib/desktop-remote-control.ts`) can grant the capability back
-/// remotely, at which point the user's own choice starts counting again.
+/// Whether the user's persistent choice or temporary snooze hides the normal
+/// shortcut reminder. Confirmed recording incidents bypass this predicate and
+/// use the same small surface only for recovery.
pub(crate) fn shortcut_overlay_hidden_by_choice(
- allow_hiding: bool,
show_overlay: bool,
+ snoozed_until: Option<i64>,
+ now_unix: i64,
) -> bool {
- allow_hiding && !show_overlay
+ !show_overlay || snoozed_until.is_some_and(|until| until > now_unix)
+}
+
+const SHORTCUT_OVERLAY_HOUR_SNOOZE_SECONDS: i64 = 60 * 60;
+
+fn should_resume_snoozed_overlay(
+ show_overlay: bool,
+ stored_until: Option<i64>,
+ expected_until: i64,
+ now_unix: i64,
+) -> bool {
+ show_overlay && stored_until == Some(expected_until) && expected_until <= now_unix
+}
+
+fn schedule_shortcut_overlay_resume(app_handle: tauri::AppHandle, expected_until: i64) {
+ tauri::async_runtime::spawn(async move {
+ let delay_seconds = expected_until
+ .saturating_sub(chrono::Utc::now().timestamp())
+ .max(0) as u64;
+ tokio::time::sleep(std::time::Duration::from_secs(delay_seconds)).await;
+
+ let Ok(Some(mut store)) = crate::store::SettingsStore::get(&app_handle) else {
+ return;
+ };
+ let now_unix = chrono::Utc::now().timestamp();
+ if !should_resume_snoozed_overlay(
+ store.show_shortcut_overlay,
+ store.shortcut_overlay_snoozed_until,
+ expected_until,
+ now_unix,
+ ) {
+ return;
+ }
+
+ store.shortcut_overlay_snoozed_until = None;
+ if let Err(error) = store.save(&app_handle) {
+ warn!("failed to clear expired shortcut overlay snooze: {}", error);
+ return;
+ }
+ if let Err(error) = show_shortcut_reminder_impl(app_handle, true, true).await {
+ warn!("failed to restore shortcut overlay after snooze: {}", error);
+ }
+ });
}
-/// Suppression is otherwise a system decision (timeline off, headless), never
-/// a stored dismissal.
+/// Honor the saved preference on every startup. Expired snoozes are cleared so
+/// Settings and subsequent launches reflect the actual state.
pub(crate) async fn maybe_show_shortcut_reminder_on_startup(
app_handle: tauri::AppHandle,
) -> Result<(), String> {
- let store = crate::store::SettingsStore::get(&app_handle)?.unwrap_or_default();
+ let mut store = crate::store::SettingsStore::get(&app_handle)?.unwrap_or_default();
+ let now_unix = chrono::Utc::now().timestamp();
if shortcut_overlay_hidden_by_choice(
- store.allow_hiding_shortcut_overlay,
store.show_shortcut_overlay,
+ store.shortcut_overlay_snoozed_until,
+ now_unix,
) {
- info!("shortcut overlay stays hidden: remote policy allows it and the user turned it off");
+ if store.show_shortcut_overlay {
+ if let Some(until) = store.shortcut_overlay_snoozed_until {
+ schedule_shortcut_overlay_resume(app_handle, until);
+ }
+ }
+ info!("shortcut overlay stays hidden: saved preference or one-hour snooze");
return Ok(());
}
+ if store
+ .shortcut_overlay_snoozed_until
+ .is_some_and(|until| until <= now_unix)
+ {
+ store.shortcut_overlay_snoozed_until = None;
+ store.save(&app_handle)?;
+ }
show_shortcut_reminder_impl(app_handle, true, true).await
}
+#[tauri::command]
+#[specta::specta]
+pub async fn snooze_shortcut_reminder_for_hour(
+ app_handle: tauri::AppHandle,
+) -> Result<(), String> {
+ let mut store = crate::store::SettingsStore::get(&app_handle)?.unwrap_or_default();
+ let until = chrono::Utc::now()
+ .timestamp()
+ .saturating_add(SHORTCUT_OVERLAY_HOUR_SNOOZE_SECONDS);
+ store.show_shortcut_overlay = true;
+ store.shortcut_overlay_snoozed_until = Some(until);
+ store.save(&app_handle)?;
+ schedule_shortcut_overlay_resume(app_handle.clone(), until);
+ hide_shortcut_reminder(app_handle).await
+}
+
#[tauri::command]
#[specta::specta]
pub async fn show_shortcut_reminder(
app_handle: tauri::AppHandle,
_shortcut: String,
) -> Result<(), String> {
+ let mut store = crate::store::SettingsStore::get(&app_handle)?.unwrap_or_default();
+ let now_unix = chrono::Utc::now().timestamp();
+ if shortcut_overlay_hidden_by_choice(
+ store.show_shortcut_overlay,
+ store.shortcut_overlay_snoozed_until,
+ now_unix,
+ ) {
+ return Ok(());
+ }
+ if store
+ .shortcut_overlay_snoozed_until
+ .is_some_and(|until| until <= now_unix)
+ {
+ store.shortcut_overlay_snoozed_until = None;
+ store.save(&app_handle)?;
+ }
show_shortcut_reminder_impl(app_handle, true, true).await
}
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs b/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs
index 5e3c498a1..7b9240140 100644
--- a/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs
+++ b/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs
@@ -13,6 +13,25 @@ use tracing::{error, info, warn};
/// Global app handle stored so native action callbacks can emit events.
static GLOBAL_APP_HANDLE: std::sync::OnceLock<tauri::AppHandle> = std::sync::OnceLock::new();
+fn handle_shortcut_overlay_hour_snooze(app: &tauri::AppHandle) {
+ let app = app.clone();
+ native_shortcut_reminder::hide();
+ tauri::async_runtime::spawn(async move {
+ let persist_succeeded = crate::commands::snooze_shortcut_reminder_for_hour(app.clone())
+ .await
+ .is_ok();
+ track_native_overlay_event(
+ &app,
+ "shortcut_reminder_dismissed",
+ serde_json::json!({
+ "dismiss_scope": "hour",
+ "snooze_hours": 1,
+ "persist_succeeded": persist_succeeded,
+ }),
+ );
+ });
+}
+
// The anchor allowlist and both store writes live in `overlay_anchor`, which is
// compiled everywhere: the native panel and the webview overlay have to agree
// on what a valid anchor is, and only one of them is macOS-only.
@@ -797,6 +816,9 @@ fn native_shortcut_action_callback_inner(action_ptr: *const std::os::raw::c_char
}
});
}
+ "dismiss_hour" => {
+ handle_shortcut_overlay_hour_snooze(&app_clone);
+ }
"restart_recording" => {
// Recording-health overlay: restart the engine in place.
// Same flow as the webview's overlay_restart_recording
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/overlay_health.rs b/apps/screenpipe-app-tauri/src-tauri/src/overlay_health.rs
index f084d1479..2f07ed6d0 100644
--- a/apps/screenpipe-app-tauri/src-tauri/src/overlay_health.rs
+++ b/apps/screenpipe-app-tauri/src-tauri/src/overlay_health.rs
@@ -591,12 +591,23 @@ async fn reveal_overlay_if_hidden(app: &tauri::AppHandle) {
if overlay_visible(app) {
return;
}
- // The overlay can no longer be dismissed, so anything hiding it now is a
- // system decision (timeline disabled, headless, or the startup show has not
- // landed yet). Leave it up after recovery rather than re-hiding it: if the
- // startup show was simply slow, hiding it again would fight that.
+ // Take responsibility for re-hiding only when this reveal overrides the
+ // user's persistent choice or active one-hour snooze. If startup is merely
+ // slow, the normal shortcut pill should stay once recovery finishes.
+ let now_unix = chrono::Utc::now().timestamp();
+ let user_wants_hidden = crate::store::SettingsStore::get(app)
+ .ok()
+ .flatten()
+ .map(|store| {
+ crate::commands::shortcut_overlay_hidden_by_choice(
+ store.show_shortcut_overlay,
+ store.shortcut_overlay_snoozed_until,
+ now_unix,
+ )
+ })
+ .unwrap_or(false);
if let Ok(mut inner) = INNER.lock() {
- inner.auto_revealed = false;
+ inner.auto_revealed = user_wants_hidden;
}
info!("overlay health: revealing hidden shortcut overlay for incident");
// Skip the disable_timeline gate and the wait-for-server handshake — the
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/store.rs b/apps/screenpipe-app-tauri/src-tauri/src/store.rs
index 56365b067..1e7152aeb 100644
--- a/apps/screenpipe-app-tauri/src-tauri/src/store.rs
+++ b/apps/screenpipe-app-tauri/src-tauri/src/store.rs
@@ -982,13 +982,15 @@ pub struct SettingsStore {
/// Overlay size: "small" (default), "medium" (1.5x), "large" (2x)
#[serde(rename = "shortcutOverlaySize", default = "default_overlay_size")]
pub shortcut_overlay_size: String,
- /// The user's choice, honored only while `allow_hiding_shortcut_overlay`
- /// is on. The overlay ships unhideable, so this is inert by default.
+ /// The user's persistent choice for the shortcut reminder. Recording-health
+ /// incidents may still reveal their own temporary recovery surface.
#[serde(rename = "showShortcutOverlay", default = "default_true")]
pub show_shortcut_overlay: bool,
- /// Remote-controlled capability (`overlay-hiding-control`), written by the
- /// desktop remote-control registry. False ships; flipping the flag on gives
- /// the Display toggle back without a release.
+ /// Unix timestamp until which the user asked to hide the shortcut reminder.
+ #[serde(rename = "shortcutOverlaySnoozedUntil", default)]
+ pub shortcut_overlay_snoozed_until: Option<i64>,
+ /// Compatibility capability written by the desktop remote-control registry.
+ /// Consumer visibility is controlled by `show_shortcut_overlay` above.
#[serde(rename = "allowHidingShortcutOverlay", default)]
pub allow_hiding_shortcut_overlay: bool,
/// Where the user dragged the overlay: one of top/bottom x left/center/right.
@@ -1594,6 +1596,7 @@ Rules:
shortcut_overlay_anchor: default_overlay_anchor(),
shortcut_overlay_display: String::new(),
show_shortcut_overlay: true,
+ shortcut_overlay_snoozed_until: None,
allow_hiding_shortcut_overlay: false,
device_id: uuid::Uuid::new_v4().to_string(),
auto_update: true,
@@ -2642,10 +2645,19 @@ mod tests {
assert_eq!(missing.shortcut_overlay_anchor, "top-center");
}
- /// Stored dismissals from before the overlay became permanent must not
- /// resurrect: the keys are gone, and an old file carrying them still loads.
#[test]
- fn retired_overlay_dismissal_keys_are_ignored() {
+ fn shortcut_overlay_preferences_survive_old_and_new_stores() {
+ let defaults = SettingsStore::default();
+ assert!(defaults.show_shortcut_overlay);
+ assert_eq!(defaults.shortcut_overlay_snoozed_until, None);
+
+ let missing: SettingsStore = serde_json::from_value(json!({
+ "aiPresets": []
+ }))
+ .unwrap();
+ assert!(missing.show_shortcut_overlay);
+ assert_eq!(missing.shortcut_overlay_snoozed_until, None);
+
let legacy: SettingsStore = serde_json::from_value(json!({
"aiPresets": [],
"showShortcutOverlay": false,
@@ -2653,7 +2665,8 @@ mod tests {
"shortcutOverlayMinimalReshowVersion": 1,
}))
.unwrap();
- assert_eq!(legacy.shortcut_overlay_anchor, "top-center");
+ assert!(!legacy.show_shortcut_overlay);
+ assert_eq!(legacy.shortcut_overlay_snoozed_until, Some(4_102_444_800));
}
#[test]
diff --git a/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift b/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift
index 0f400d852..3756da306 100644
--- a/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift
+++ b/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift
@@ -1138,7 +1138,7 @@ struct ShortcutReminderView: View {
Rectangle().fill(.white.opacity(0.28)).frame(width: 1).padding(.vertical, s(4))
DockIconButton(icon: "gearshape", active: metrics.hoveredControl == "settings", scale: scale) {
- onAction("open_overlay_settings")
+ onAction("show_settings_menu")
}
}
.frame(width: kBaseExpandedW * scale, height: kBaseDockH * scale)
@@ -2795,7 +2795,11 @@ class ShortcutReminderController: NSObject, NSWindowDelegate {
metrics: metrics,
scale: gOverlayScale,
onAction: { [weak self] action in
- self?.sendAction(action)
+ if action == "show_settings_menu" {
+ self?.showShortcutSettingsMenu()
+ } else {
+ self?.sendAction(action)
+ }
}
)
let contentView = panel.contentView!
@@ -3039,6 +3043,49 @@ class ShortcutReminderController: NSObject, NSWindowDelegate {
}
}
+ /// Wispr-style native menu: one temporary escape beside the floating bar,
+ /// with the durable choice kept in Settings. Using AppKit's menu avoids a
+ /// second floating panel and inherits keyboard, screen-edge and VoiceOver
+ /// behavior from macOS.
+ private func showShortcutSettingsMenu() {
+ guard let contentView = panel?.contentView else { return }
+ let menu = NSMenu(title: "shortcut reminder")
+ menu.autoenablesItems = false
+
+ let snooze = NSMenuItem(
+ title: "Hide for 1 hour",
+ action: #selector(hideShortcutReminderForHour),
+ keyEquivalent: ""
+ )
+ snooze.target = self
+ snooze.isEnabled = true
+ menu.addItem(snooze)
+ menu.addItem(.separator())
+
+ let settings = NSMenuItem(
+ title: "Settings…",
+ action: #selector(openShortcutReminderSettings),
+ keyEquivalent: ""
+ )
+ settings.target = self
+ settings.isEnabled = true
+ menu.addItem(settings)
+
+ menu.popUp(
+ positioning: nil,
+ at: NSPoint(x: contentView.bounds.maxX - 4, y: contentView.bounds.minY + 4),
+ in: contentView
+ )
+ }
+
+ @objc private func hideShortcutReminderForHour() {
+ sendAction("dismiss_hour")
+ }
+
+ @objc private func openShortcutReminderSettings() {
+ sendAction("open_overlay_settings")
+ }
+
private func sendAction(_ action: String) {
guard let cb = gShortcutCallback else { return }
action.withCString { cb($0) }
diff --git a/crates/screenpipe-overlay-win/src/actions.rs b/crates/screenpipe-overlay-win/src/actions.rs
index 934bf8f66..0d43385c9 100644
--- a/crates/screenpipe-overlay-win/src/actions.rs
+++ b/crates/screenpipe-overlay-win/src/actions.rs
@@ -16,6 +16,8 @@ use crate::state::{Anchor, Control, OverlayState};
pub const NOTIFICATION_ACTION_PREFIX: &str = "notification_action:";
pub const ANCHOR_PREFIX: &str = "set_overlay_anchor:";
pub const MEETING_NOTE_PREFIX: &str = "open_meeting_note:";
+pub const SETTINGS_MENU_HIDE_HOUR: usize = 1;
+pub const SETTINGS_MENU_OPEN_SETTINGS: usize = 2;
/// The action string for a control, or `None` when the control has nothing to
/// report — either because it is a status cell rather than a button, or because
@@ -27,7 +29,9 @@ pub fn action_for(state: &OverlayState, control: Control) -> Option<String> {
Control::Pill | Control::Timeline => "open_timeline",
Control::Search => "open_search",
Control::Chat => "open_chat",
- Control::Settings => "open_overlay_settings",
+ // The native window owns the compact settings menu. Its selected item
+ // is translated by `settings_menu_action` below.
+ Control::Settings => return None,
Control::RestartRecording => "restart_recording",
Control::DismissIncident => "dismiss_incident",
// The audio meter is a status cell, not a button — same as the mac
@@ -63,6 +67,16 @@ pub fn action_for(state: &OverlayState, control: Control) -> Option<String> {
Some(fixed.to_string())
}
+/// Translate the native settings-menu command id into the same app actions
+/// used by the macOS panel and web fallback.
+pub fn settings_menu_action(command: usize) -> Option<String> {
+ match command {
+ SETTINGS_MENU_HIDE_HOUR => Some("dismiss_hour".to_string()),
+ SETTINGS_MENU_OPEN_SETTINGS => Some("open_overlay_settings".to_string()),
+ _ => None,
+ }
+}
+
/// Reported after a drag settles. Kebab-case so it lands in `shortcutOverlayAnchor`
/// in the shape `overlay-anchor.ts` and the settings store already use.
pub fn anchor_action(anchor: Anchor) -> String {
@@ -102,16 +116,26 @@ mod tests {
assert_eq!(action_for(&s, Control::Chat).unwrap(), "open_chat");
assert_eq!(action_for(&s, Control::Timeline).unwrap(), "open_timeline");
assert_eq!(action_for(&s, Control::Pill).unwrap(), "open_timeline");
- assert_eq!(
- action_for(&s, Control::Settings).unwrap(),
- "open_overlay_settings"
- );
+ assert_eq!(action_for(&s, Control::Settings), None);
assert_eq!(
action_for(&s, Control::RestartRecording).unwrap(),
"restart_recording"
);
}
+ #[test]
+ fn settings_menu_matches_the_other_native_overlay() {
+ assert_eq!(
+ settings_menu_action(SETTINGS_MENU_HIDE_HOUR).unwrap(),
+ "dismiss_hour"
+ );
+ assert_eq!(
+ settings_menu_action(SETTINGS_MENU_OPEN_SETTINGS).unwrap(),
+ "open_overlay_settings"
+ );
+ assert_eq!(settings_menu_action(99), None);
+ }
+
#[test]
fn the_first_notification_button_is_the_primary_one() {
// Button 0 is drawn rightmost and is the primary — clicking "open note"
diff --git a/crates/screenpipe-overlay-win/src/window.rs b/crates/screenpipe-overlay-win/src/window.rs
index 961496774..b5d0bfbac 100644
--- a/crates/screenpipe-overlay-win/src/window.rs
+++ b/crates/screenpipe-overlay-win/src/window.rs
@@ -22,7 +22,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::{Arc, Mutex};
-use windows::core::Result;
+use windows::core::{w, Result};
use windows::Win32::Foundation::{COLORREF, HWND, LPARAM, LRESULT, POINT, RECT, SIZE, WPARAM};
use windows::Win32::Graphics::Direct2D::Common::{D2D1_COLOR_F, D2D_POINT_2F};
use windows::Win32::Graphics::Direct2D::{
@@ -43,17 +43,22 @@ use windows::Win32::UI::Input::KeyboardAndMouse::{
ReleaseCapture, SetCapture, TrackMouseEvent, TME_LEAVE, TRACKMOUSEEVENT,
};
use windows::Win32::UI::WindowsAndMessaging::{
- CreateWindowExW, DefWindowProcW, DestroyWindow, DispatchMessageW, GetCursorPos, GetMessageW,
- GetWindowLongPtrW, GetWindowRect, KillTimer, LoadCursorW, PostMessageW, PostQuitMessage,
- RegisterClassExW, SetTimer, SetWindowLongPtrW, SetWindowPos, ShowWindow, TranslateMessage,
- UpdateLayeredWindow, CS_HREDRAW, CS_VREDRAW, GWLP_USERDATA, HWND_TOPMOST, IDC_ARROW, MSG,
- SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOSIZE, SW_HIDE, SW_SHOWNOACTIVATE, ULW_ALPHA, WINDOWPOS,
- WM_APP, WM_DESTROY, WM_DISPLAYCHANGE, WM_DPICHANGED, WM_LBUTTONDOWN, WM_LBUTTONUP,
- WM_MOUSEMOVE, WM_SETTINGCHANGE, WM_TIMER, WM_WINDOWPOSCHANGING, WNDCLASSEXW, WS_EX_LAYERED,
- WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, WS_EX_TOPMOST, WS_EX_TRANSPARENT, WS_POPUP,
+ AppendMenuW, CreatePopupMenu, CreateWindowExW, DefWindowProcW, DestroyMenu, DestroyWindow,
+ DispatchMessageW, GetCursorPos, GetMessageW, GetWindowLongPtrW, GetWindowRect, KillTimer,
+ LoadCursorW, PostMessageW, PostQuitMessage, RegisterClassExW, SetTimer, SetWindowLongPtrW,
+ SetWindowPos, ShowWindow, TrackPopupMenu, TranslateMessage, UpdateLayeredWindow, CS_HREDRAW,
+ CS_VREDRAW, GWLP_USERDATA, HWND_TOPMOST, IDC_ARROW, MF_SEPARATOR, MF_STRING, MSG,
+ SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOSIZE, SW_HIDE, SW_SHOWNOACTIVATE, TPM_RETURNCMD,
+ TPM_RIGHTALIGN, TPM_TOPALIGN, ULW_ALPHA, WINDOWPOS, WM_APP, WM_DESTROY, WM_DISPLAYCHANGE,
+ WM_DPICHANGED, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MOUSEMOVE, WM_SETTINGCHANGE, WM_TIMER,
+ WM_WINDOWPOSCHANGING, WNDCLASSEXW, WS_EX_LAYERED, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW,
+ WS_EX_TOPMOST, WS_EX_TRANSPARENT, WS_POPUP,
};
-use crate::actions::{action_for, anchor_action};
+use crate::actions::{
+ action_for, anchor_action, settings_menu_action, SETTINGS_MENU_HIDE_HOUR,
+ SETTINGS_MENU_OPEN_SETTINGS,
+};
use crate::anim::Equalizer;
use crate::drag_stage;
use crate::layout::{self, Layout, SHADOW_PAD};
@@ -82,6 +87,45 @@ const HOVER_POLL_MS: u32 = 90;
/// Pointer travel before a press on the pill becomes a drag rather than a click.
const DRAG_THRESHOLD: f32 = 4.0;
+/// Show the same two-choice native menu as the macOS overlay. Returning the
+/// selected app action keeps menu presentation inside the Win32 window while
+/// preserving the cross-platform callback contract.
+unsafe fn show_settings_menu(hwnd: HWND) -> Option<String> {
+ let menu = CreatePopupMenu().ok()?;
+ let result = (|| {
+ AppendMenuW(
+ menu,
+ MF_STRING,
+ SETTINGS_MENU_HIDE_HOUR,
+ w!("Hide for 1 hour"),
+ )
+ .ok()?;
+ AppendMenuW(menu, MF_SEPARATOR, 0, w!("")).ok()?;
+ AppendMenuW(
+ menu,
+ MF_STRING,
+ SETTINGS_MENU_OPEN_SETTINGS,
+ w!("Settings..."),
+ )
+ .ok()?;
+
+ let mut point = POINT::default();
+ GetCursorPos(&mut point).ok()?;
+ let command = TrackPopupMenu(
+ menu,
+ TPM_RETURNCMD | TPM_RIGHTALIGN | TPM_TOPALIGN,
+ point.x,
+ point.y,
+ 0,
+ hwnd,
+ None,
+ );
+ settings_menu_action(command.0 as usize)
+ })();
+ let _ = DestroyMenu(menu);
+ result
+}
+
/// Gap in DIP between the pinned pill and the edge of the work area. Shared
/// with the drag stage so a landing target is drawn exactly where the pill it
/// stands for will come to rest.
@@ -1279,7 +1323,11 @@ extern "system" fn wndproc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM)
// Only fire when the release lands on the same control
// the press did — dragging off a button cancels it.
if ctx.layout.hit_test(x, y) == Some(pressed) {
- action = action_for(&ctx.state, pressed);
+ action = if pressed == Control::Settings {
+ show_settings_menu(hwnd)
+ } else {
+ action_for(&ctx.state, pressed)
+ };
// Pinning is the overlay's own state, so it is applied
// here rather than reported and echoed back.
if pressed == Control::TranscriptPin {
diff --git a/docs/assets/pr/shortcut-overlay-hide-menu.png b/docs/assets/pr/shortcut-overlay-hide-menu.png
new file mode 100644
index 000000000..a8473601a
Binary files /dev/null and b/docs/assets/pr/shortcut-overlay-hide-menu.png differ