vcli-input: InputSink + CGEvent backend + Cmd+Shift+Esc kill switch

Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "crates/vcli-core",
     "crates/vcli-capture",
     "crates/vcli-dsl",
+    "crates/vcli-input",
     "crates/vcli-ipc",
     "crates/vcli-perception",
     "crates/vcli-store",
@@ -37,8 +38,10 @@ hex = "0.4"
 
 tracing = "0.1"
 
-# Platform-specific, referenced from vcli-capture only. Declaring here so
-# downstream crates that later depend on vcli-capture don't re-select versions.
+# Platform-specific (used by vcli-input + vcli-capture)
+core-graphics = { version = "0.24", features = ["highsierra"] }
+core-foundation = "0.10"
+libc = "0.2"
 screencapturekit = "1"
 
 # Added by vcli-perception lane

crates/vcli-input/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "vcli-input"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+authors.workspace = true
+description = "Input synthesis trait, macOS CGEvent backend, mock, and HIL kill switch for vcli."
+
+[dependencies]
+vcli-core = { path = "../vcli-core" }
+thiserror = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+core-graphics = { workspace = true }
+core-foundation = { workspace = true }
+libc = { workspace = true }
+
+[dev-dependencies]
+tempfile = { workspace = true }
+proptest = { workspace = true }

crates/vcli-input/README.md

@@ -0,0 +1,5 @@
+# vcli-input
+
+Input synthesis. Real macOS CGEvent backend, a mock, and a human-in-the-loop kill switch.
+
+See the design spec at `docs/superpowers/specs/2026-04-16-vcli-design.md` §Input synthesis.

crates/vcli-input/src/error.rs

@@ -0,0 +1,86 @@
+//! Errors surfaced by [`crate::sink::InputSink`] implementations.
+
+use thiserror::Error;
+use vcli_core::ErrorCode;
+
+/// Error returned by every `InputSink` method. `Halted` wins over all others
+/// because the kill switch short-circuits before the backend is even called.
+#[derive(Debug, Error)]
+pub enum InputError {
+    /// The kill switch was set; no OS event was posted.
+    #[error("input halted: kill switch is engaged")]
+    Halted,
+
+    /// macOS TCC (Accessibility / Input Monitoring) has not granted this process
+    /// permission to synthesize input.
+    #[error("input permission denied: {detail}")]
+    PermissionDenied {
+        /// Short human-readable reason — which TCC bucket is missing.
+        detail: String,
+    },
+
+    /// Event creation / posting failed at the OS layer.
+    #[error("backend failure: {detail}")]
+    Backend {
+        /// Error message from the OS / FFI call.
+        detail: String,
+    },
+
+    /// Unknown key name in a key-combo action.
+    #[error("unknown key: {0}")]
+    UnknownKey(String),
+
+    /// Invalid argument (e.g. empty drag path, `hold_ms > 60_000`).
+    #[error("invalid input argument: {0}")]
+    InvalidArgument(String),
+
+    /// Platform does not support this method (Windows stub in v0).
+    #[error("not implemented on this platform")]
+    Unimplemented,
+}
+
+impl InputError {
+    /// Map to the IPC wire-level [`ErrorCode`]. `Halted` maps to `internal`
+    /// because it is a local-only condition with no external counterpart.
+    #[must_use]
+    pub fn to_error_code(&self) -> ErrorCode {
+        match self {
+            Self::Halted | Self::Backend { .. } | Self::Unimplemented => ErrorCode::Internal,
+            Self::PermissionDenied { .. } => ErrorCode::PermissionDenied,
+            Self::UnknownKey(_) | Self::InvalidArgument(_) => ErrorCode::InvalidProgram,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn halted_display_is_stable() {
+        assert_eq!(
+            InputError::Halted.to_string(),
+            "input halted: kill switch is engaged"
+        );
+    }
+
+    #[test]
+    fn permission_maps_to_permission_denied() {
+        let e = InputError::PermissionDenied {
+            detail: "Accessibility".into(),
+        };
+        assert_eq!(e.to_error_code(), ErrorCode::PermissionDenied);
+    }
+
+    #[test]
+    fn unknown_key_maps_to_invalid_program() {
+        let e = InputError::UnknownKey("blargh".into());
+        assert_eq!(e.to_error_code(), ErrorCode::InvalidProgram);
+        assert!(e.to_string().contains("blargh"));
+    }
+
+    #[test]
+    fn halted_maps_to_internal() {
+        assert_eq!(InputError::Halted.to_error_code(), ErrorCode::Internal);
+    }
+}