feat: add double-tap gesture for configurable terminal action

Opt-in gesture (disabled by default) that sends configurable data on
double-tap of the terminal screen. Default data is \x02z (tmux pane
zoom toggle). Configurable via gestures.doubleTap.{enabled,data,maxInterval}.

Spatial proximity check (50px) prevents unrelated taps triggering.
touch-action:manipulation on .xterm-screen disables browser double-tap
zoom without needing preventDefault (consistent with d40fa46).

Author: connorads

.agents/skills/remobi-setup/SKILL.md

@@ -393,6 +393,9 @@ Valid positions: `top-left | top-right | top-centre | bottom-left | bottom-right
 | `gestures.scroll.strategy` | `'wheel'` | `'wheel'` (recommended) sends SGR mouse wheel sequences — works in vim, less, htop. `'keys'` sends PageUp/PageDown — simpler, works everywhere |
 | `gestures.scroll.sensitivity` | `40` | |
 | `gestures.scroll.wheelIntervalMs` | `24` | |
+| `gestures.doubleTap.enabled` | `false` | Opt-in double-tap gesture on terminal screen |
+| `gestures.doubleTap.data` | `'\x02z'` | Data to send on double-tap (default: tmux zoom toggle) |
+| `gestures.doubleTap.maxInterval` | `300` | Max milliseconds between taps |
 
 ### Font
 

src/config-schema.ts

@@ -190,16 +190,30 @@ const scrollResolvedSchema = v.strictObject({
 	wheelIntervalMs: finiteNumber,
 })
 
+const doubleTapOverridesSchema = v.strictObject({
+	enabled: v.optional(v.boolean()),
+	data: v.optional(v.string()),
+	maxInterval: v.optional(finiteNumber),
+})
+
+const doubleTapResolvedSchema = v.strictObject({
+	enabled: v.boolean(),
+	data: v.string(),
+	maxInterval: finiteNumber,
+})
+
 const gestureOverridesSchema = v.strictObject({
 	swipe: v.optional(swipeOverridesSchema),
 	pinch: v.optional(pinchOverridesSchema),
 	scroll: v.optional(scrollOverridesSchema),
+	doubleTap: v.optional(doubleTapOverridesSchema),
 })
 
 const gestureResolvedSchema = v.strictObject({
 	swipe: swipeResolvedSchema,
 	pinch: pinchResolvedSchema,
 	scroll: scrollResolvedSchema,
+	doubleTap: doubleTapResolvedSchema,
 })
 
 // --- Mobile ---

src/config.ts

@@ -30,6 +30,7 @@ const defaultGestures: RemobiConfig['gestures'] = {
 	},
 	pinch: { enabled: false },
 	scroll: { enabled: true, sensitivity: 40, strategy: 'wheel', wheelIntervalMs: 24 },
+	doubleTap: { enabled: false, data: '\x02z', maxInterval: 300 },
 }
 
 /** Default row 1 buttons (prefix + nav) */

src/controls/help.ts

@@ -46,6 +46,10 @@ function renderGestures(config: RemobiConfig): DocumentFragment {
 		}
 	}
 
+	if (config.gestures.doubleTap.enabled) {
+		table.appendChild(row('Double-tap', 'Toggle pane zoom (configurable)'))
+	}
+
 	if (table.rows.length === 0) {
 		table.appendChild(row('None', 'All gestures are disabled in config'))
 	}

src/gestures/double-tap.ts

@@ -0,0 +1,83 @@
+import type { DoubleTapConfig, XTerminal } from '../types'
+import { haptic } from '../util/haptic'
+import { sendData } from '../util/terminal'
+
+const MAX_TAP_MOVEMENT = 10
+const MAX_TAP_DISTANCE = 50
+
+/** Pure logic: is this a valid double-tap? */
+export function isDoubleTap(
+	dt: number,
+	distance: number,
+	maxInterval: number,
+	maxDistance: number,
+): boolean {
+	return dt > 0 && dt <= maxInterval && distance <= maxDistance
+}
+
+/** Attach double-tap gesture detection to the xterm screen */
+export function attachDoubleTapGesture(
+	term: XTerminal,
+	config: DoubleTapConfig,
+	isDrawerOpen: () => boolean,
+): void {
+	let lastTapTime = 0
+	let lastTapX = 0
+	let lastTapY = 0
+	let startX = 0
+	let startY = 0
+
+	function onTouchStart(e: TouchEvent): void {
+		if (e.touches.length !== 1) return
+		const touch = e.touches[0]
+		if (!touch) return
+		startX = touch.clientX
+		startY = touch.clientY
+	}
+
+	function onTouchEnd(e: TouchEvent): void {
+		if (isDrawerOpen() || e.changedTouches.length !== 1) return
+		const touch = e.changedTouches[0]
+		if (!touch) return
+
+		// Reject if finger moved too far (was a scroll/swipe, not a tap)
+		const moveDx = touch.clientX - startX
+		const moveDy = touch.clientY - startY
+		if (Math.sqrt(moveDx * moveDx + moveDy * moveDy) > MAX_TAP_MOVEMENT) return
+
+		const now = Date.now()
+		const dt = now - lastTapTime
+		const tapDx = touch.clientX - lastTapX
+		const tapDy = touch.clientY - lastTapY
+		const distance = Math.sqrt(tapDx * tapDx + tapDy * tapDy)
+
+		if (isDoubleTap(dt, distance, config.maxInterval, MAX_TAP_DISTANCE)) {
+			sendData(term, config.data)
+			haptic()
+			// Reset to prevent triple-tap
+			lastTapTime = 0
+		} else {
+			lastTapTime = now
+			lastTapX = touch.clientX
+			lastTapY = touch.clientY
+		}
+	}
+
+	function attach(): void {
+		const screen = document.querySelector('.xterm-screen')
+		if (!screen) {
+			setTimeout(attach, 200)
+			return
+		}
+		// oxlint-disable-next-line typescript/consistent-type-assertions -- DOM addEventListener types Event, not TouchEvent
+		screen.addEventListener('touchstart', (e: Event) => onTouchStart(e as TouchEvent), {
+			passive: true,
+		})
+		// oxlint-disable-next-line typescript/consistent-type-assertions -- DOM addEventListener types Event, not TouchEvent
+		screen.addEventListener('touchend', (e: Event) => onTouchEnd(e as TouchEvent), {
+			passive: true,
+		})
+	}
+
+	attach()
+}

src/index.ts

@@ -6,6 +6,7 @@ import { createFontControls } from './controls/font-size'
 import { createHelpOverlay } from './controls/help'
 import { createScrollButtons } from './controls/scroll-buttons'
 import { createDrawer } from './drawer/drawer'
+import { attachDoubleTapGesture } from './gestures/double-tap'
 import { createGestureLock } from './gestures/lock'
 import { attachPinchGestures } from './gestures/pinch'
 import { attachScrollGesture } from './gestures/scroll'
@@ -163,6 +164,9 @@ export function init(
 				if (config.gestures.scroll.enabled) {
 					attachScrollGesture(term, config.gestures.scroll, gestureLock, drawer.isOpen)
 				}
+				if (config.gestures.doubleTap.enabled) {
+					attachDoubleTapGesture(term, config.gestures.doubleTap, drawer.isOpen)
+				}
 
 				// Height management
 				initHeightManager(toolbar)

src/types.ts

@@ -74,11 +74,19 @@ export interface ScrollConfig {
 	readonly wheelIntervalMs: number
 }
 
+/** Double-tap gesture configuration */
+export interface DoubleTapConfig {
+	readonly enabled: boolean
+	readonly data: string
+	readonly maxInterval: number
+}
+
 /** Gesture configuration */
 export interface GestureConfig {
 	readonly swipe: SwipeConfig
 	readonly pinch: PinchConfig
 	readonly scroll: ScrollConfig
+	readonly doubleTap: DoubleTapConfig
 }
 
 /** Mobile-specific behaviour configuration */

styles/base.css

@@ -8,6 +8,7 @@ body {
 @media (pointer: coarse) {
 	.xterm-screen {
 		overscroll-behavior: none;
+		touch-action: manipulation;
 	}
 }
 

tests/config-validate.test.ts

@@ -99,6 +99,37 @@ describe('assertValidConfigOverrides', () => {
 		expect(message).toContain('string')
 	})
 
+	test('accepts valid doubleTap overrides', () => {
+		expect(() =>
+			assertValidConfigOverrides({
+				gestures: { doubleTap: { enabled: true } },
+			}),
+		).not.toThrow()
+		expect(() =>
+			assertValidConfigOverrides({
+				gestures: { doubleTap: { data: '\x01z', maxInterval: 500 } },
+			}),
+		).not.toThrow()
+	})
+
+	test('rejects non-string doubleTap data', () => {
+		const message = getValidationMessage(
+			{ gestures: { doubleTap: { data: 42 } } },
+			assertValidConfigOverrides,
+		)
+		expect(message).toContain('config.gestures.doubleTap.data')
+		expect(message).toContain('string')
+	})
+
+	test('rejects non-number doubleTap maxInterval', () => {
+		const message = getValidationMessage(
+			{ gestures: { doubleTap: { maxInterval: 'fast' } } },
+			assertValidConfigOverrides,
+		)
+		expect(message).toContain('config.gestures.doubleTap.maxInterval')
+		expect(message).toContain('number')
+	})
+
 	test('accepts valid partial mobile overrides including null initData', () => {
 		expect(() => assertValidConfigOverrides({ mobile: { initData: null } })).not.toThrow()
 		expect(() => assertValidConfigOverrides({ mobile: { initData: '\x02z' } })).not.toThrow()
@@ -319,6 +350,7 @@ describe('assertValidResolvedConfig', () => {
 					},
 					pinch: { enabled: false },
 					scroll: { enabled: true, sensitivity: 40, strategy: 'wheel', wheelIntervalMs: 24 },
+					doubleTap: { enabled: false, data: '\x02z', maxInterval: 300 },
 				},
 				mobile: { initData: null, widthThreshold: 768 },
 				floatingButtons: [],

tests/gestures.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'vitest'
+import { isDoubleTap } from '../src/gestures/double-tap'
 import { createGestureLock, resetLock, tryLock } from '../src/gestures/lock'
 import { clampFontSize, touchDistance } from '../src/gestures/pinch'
 import {
@@ -291,6 +292,51 @@ describe('touchToCell', () => {
 	})
 })
 
+describe('isDoubleTap', () => {
+	const maxInterval = 300
+	const maxDistance = 50
+
+	test('within interval and distance returns true', () => {
+		expect(isDoubleTap(200, 30, maxInterval, maxDistance)).toBe(true)
+	})
+
+	test('exceeds interval returns false', () => {
+		expect(isDoubleTap(400, 30, maxInterval, maxDistance)).toBe(false)
+	})
+
+	test('zero dt (simultaneous) returns false', () => {
+		expect(isDoubleTap(0, 10, maxInterval, maxDistance)).toBe(false)
+	})
+
+	test('exact interval boundary returns true', () => {
+		expect(isDoubleTap(300, 30, maxInterval, maxDistance)).toBe(true)
+	})
+
+	test('negative dt returns false', () => {
+		expect(isDoubleTap(-100, 10, maxInterval, maxDistance)).toBe(false)
+	})
+
+	test('within distance returns true', () => {
+		expect(isDoubleTap(200, 49, maxInterval, maxDistance)).toBe(true)
+	})
+
+	test('exceeds distance returns false', () => {
+		expect(isDoubleTap(200, 60, maxInterval, maxDistance)).toBe(false)
+	})
+
+	test('exact distance boundary returns true', () => {
+		expect(isDoubleTap(200, 50, maxInterval, maxDistance)).toBe(true)
+	})
+
+	test('within time but too far apart returns false', () => {
+		expect(isDoubleTap(100, 80, maxInterval, maxDistance)).toBe(false)
+	})
+
+	test('close enough but too slow returns false', () => {
+		expect(isDoubleTap(500, 10, maxInterval, maxDistance)).toBe(false)
+	})
+})
+
 describe('resolveScrollAction', () => {
 	test('keys strategy returns pageSeq for up', () => {
 		const action = resolveScrollAction('up', 'keys', { x: 1, y: 1 }, 0, 1000, 50)