palmier 0.8.0 → 0.8.1

package/palmier-server/pwa/src/components/SessionsView.tsx

@@ -256,9 +256,15 @@ export default function SessionsView({ connected, hostId, request, subscribeEven
             <div className="sessions-card-body">
               <h3 className="sessions-card-name">{entry.task_name || entry.task_id}</h3>
               <div className="sessions-card-meta">
-                <span style={{ color: stateColor(entry.running_state) }}>
-                  {stateLabel[entry.running_state ?? ""] ?? entry.running_state}
-                </span>
+                {entry.running_state === "started" ? (
+                  <span className="status-spinner" aria-label="Running">
+                    <span />
+                  </span>
+                ) : (
+                  <span style={{ color: stateColor(entry.running_state) }}>
+                    {stateLabel[entry.running_state ?? ""] ?? entry.running_state}
+                  </span>
+                )}
                 {entry.end_time && <span>{formatTime(entry.end_time)}</span>}
                 {entry.start_time && entry.end_time && (
                   <span style={{ color: "var(--color-muted)" }}>

package/palmier-server/pwa/src/components/TaskCard.tsx

@@ -23,7 +23,9 @@ export default function TaskCard({ task, lastEvent, onEdit, onDelete, onViewRun
   const menuRef = useRef<HTMLDivElement>(null);
 
   const isRunning = lastEvent?.running_state === "started";
-  const scheduleActive = !!task.schedule_enabled && !!task.schedule_type && (task.schedule_values?.length ?? 0) > 0;
+  const hasScheduleValues = (task.schedule_values?.length ?? 0) > 0;
+  const isEventSchedule = task.schedule_type === "on_new_notification" || task.schedule_type === "on_new_sms";
+  const scheduleActive = !!task.schedule_enabled && !!task.schedule_type && (hasScheduleValues || isEventSchedule);
   const stateColor =
     !scheduleActive
       ? "var(--color-text-secondary)"
@@ -126,8 +128,14 @@ export default function TaskCard({ task, lastEvent, onEdit, onDelete, onViewRun
     return `${c.kind.charAt(0).toUpperCase() + c.kind.slice(1)}: ${c.detail}`;
   }
 
-  function formatScheduleGrouped(scheduleType: "crons" | "specific_times" | undefined, values: string[] | undefined): string {
-    if (!scheduleType || !values || values.length === 0) return "";
+  function formatScheduleGrouped(
+    scheduleType: "crons" | "specific_times" | "on_new_notification" | "on_new_sms" | undefined,
+    values: string[] | undefined,
+  ): string {
+    if (!scheduleType) return "";
+    if (scheduleType === "on_new_notification") return "On new push notification";
+    if (scheduleType === "on_new_sms") return "On new SMS";
+    if (!values || values.length === 0) return "";
     if (values.length === 1) return formatSingleValue(scheduleType, values[0]);
 
     const classified = values.map((v) => classifyValue(scheduleType, v));
@@ -214,7 +222,7 @@ export default function TaskCard({ task, lastEvent, onEdit, onDelete, onViewRun
               {" "}{formatTime(lastEvent.time_stamp)}
             </span>
           )}
-          {task.schedule_type && (task.schedule_values?.length ?? 0) > 0 && (
+          {task.schedule_type && (hasScheduleValues || isEventSchedule) && (
             <span className="task-card-triggers">
               {task.schedule_enabled ? scheduleText : "Schedule disabled"}
             </span>

package/palmier-server/pwa/src/components/TaskForm.tsx

@@ -4,19 +4,24 @@ import PlanDialog from "./PlanDialog";
 import { useBackClose } from "../hooks/useBackClose";
 import type { AgentInfo, Task } from "../types";
 
-type ScheduleType = "crons" | "specific_times";
+type ScheduleType = "crons" | "specific_times" | "on_new_notification" | "on_new_sms";
+type EventMode = "on_new_notification" | "on_new_sms";
 
 
 const DAYS_OF_WEEK = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
 
 type ScheduleSlot = "specific_times" | "hourly" | "daily" | "weekly" | "monthly";
-type ScheduleMode = "ondemand" | "command" | ScheduleSlot;
+type ScheduleMode = "ondemand" | "command" | EventMode | ScheduleSlot;
 
 const SCHEDULE_SLOTS: readonly ScheduleMode[] = ["specific_times", "hourly", "daily", "weekly", "monthly"];
 function isScheduleSlot(mode: ScheduleMode): mode is ScheduleSlot {
   return (SCHEDULE_SLOTS as readonly string[]).includes(mode);
 }
 
+function isEventMode(mode: ScheduleMode): mode is EventMode {
+  return mode === "on_new_notification" || mode === "on_new_sms";
+}
+
 interface TriggerRow {
   schedule: ScheduleSlot;
   time: string;
@@ -41,7 +46,7 @@ function cronToRow(cron: string): TriggerRow {
   return { ...newRow("daily"), time };
 }
 
-function valueToRow(scheduleType: ScheduleType, value: string): TriggerRow {
+function valueToRow(scheduleType: "crons" | "specific_times", value: string): TriggerRow {
   if (scheduleType === "specific_times") {
     const [datePart, timePart] = value.split("T");
     return { ...newRow("specific_times"), onceDate: datePart ?? "", onceTime: (timePart ?? "09:00").slice(0, 5) };
@@ -67,15 +72,21 @@ function rowToValue(row: TriggerRow): string | null {
   return rowToCron(row);
 }
 
-function modeToScheduleType(mode: ScheduleSlot): ScheduleType {
-  return mode === "specific_times" ? "specific_times" : "crons";
+function modeToScheduleType(mode: ScheduleSlot | EventMode): ScheduleType {
+  if (mode === "specific_times") return "specific_times";
+  if (mode === "on_new_notification") return "on_new_notification";
+  if (mode === "on_new_sms") return "on_new_sms";
+  return "crons";
 }
 
 function initialScheduleMode(initial?: Task): ScheduleMode {
-  if (initial?.command) return "command";
-  const type = initial?.schedule_type;
-  const first = initial?.schedule_values?.[0];
-  if (!type || !first) return "ondemand";
+  if (!initial) return "daily";
+  if (initial.command) return "command";
+  const type = initial.schedule_type;
+  if (type === "on_new_notification" || type === "on_new_sms") return type;
+  if (type !== "crons" && type !== "specific_times") return "ondemand";
+  const first = initial.schedule_values?.[0];
+  if (!first) return "ondemand";
   return valueToRow(type, first).schedule;
 }
 
@@ -113,13 +124,17 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
     () => {
       const type = initial?.schedule_type;
       const values = initial?.schedule_values;
-      if (!type || !values) return [];
-      return values.map((v) => valueToRow(type, v));
+      if (values && (type === "crons" || type === "specific_times")) {
+        return values.map((v) => valueToRow(type, v));
+      }
+      const mode = initialScheduleMode(initial);
+      return isScheduleSlot(mode) ? [newRow(mode)] : [];
     }
   );
   const [requiresConfirmation, setRequiresConfirmation] = useState(
     initial?.requires_confirmation ?? false
   );
+  const [scheduleEnabled, setScheduleEnabled] = useState(initial?.schedule_enabled ?? true);
   const [yoloMode, setYoloMode] = useState(initial?.yolo_mode ?? false);
   const [foregroundMode, setForegroundMode] = useState(initial?.foreground_mode ?? false);
   const [command, setCommand] = useState(initial?.command ?? "");
@@ -129,6 +144,7 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
 
   const modeIsScheduled = isScheduleSlot(scheduleMode);
   const modeIsCommand = scheduleMode === "command";
+  const modeIsEvent = isEventMode(scheduleMode);
 
   const selectedAgent = agents.find((a) => a.key === agent);
   const agentSupportsYolo = !!selectedAgent?.supportsYolo;
@@ -145,13 +161,15 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
     || agent !== (initial?.agent ?? "")
     || scheduleMode !== initialMode
     || requiresConfirmation !== (initial?.requires_confirmation ?? false)
+    || scheduleEnabled !== (initial?.schedule_enabled ?? true)
     || yoloMode !== (initial?.yolo_mode ?? false)
     || foregroundMode !== (initial?.foreground_mode ?? false)
     || (modeIsCommand && command !== (initial?.command ?? ""))
     || (modeIsScheduled && (
       JSON.stringify(collectScheduleValues()) !== JSON.stringify(initial?.schedule_values ?? [])
       || modeToScheduleType(scheduleMode as ScheduleSlot) !== (initial?.schedule_type ?? undefined)
-    ));
+    ))
+    || (modeIsEvent && scheduleMode !== initial?.schedule_type);
 
   const hasInvalidTrigger = modeIsScheduled && triggerRows.some((r) =>
     r.schedule === "specific_times" && (!r.onceDate || new Date(`${r.onceDate}T${r.onceTime}`) <= new Date())
@@ -172,7 +190,7 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
 
   function addRow() {
     if (!isScheduleSlot(scheduleMode)) return;
-    setTriggerRows((prev) => [...prev, newRow(scheduleMode)]);
+    setTriggerRows((prev) => [...prev, prev.length > 0 ? { ...prev[prev.length - 1] } : newRow(scheduleMode)]);
   }
 
   function changeScheduleMode(next: ScheduleMode) {
@@ -212,14 +230,18 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
     setError(null);
     try {
       const scheduleValues = modeIsScheduled ? collectScheduleValues() : [];
-      const hasSchedule = scheduleValues.length > 0;
+      const scheduleType: ScheduleType | null = modeIsScheduled
+        ? modeToScheduleType(scheduleMode as ScheduleSlot)
+        : modeIsEvent
+          ? modeToScheduleType(scheduleMode as EventMode)
+          : null;
       const payload: Record<string, unknown> = {
         user_prompt: userPrompt,
         agent,
-        schedule_type: hasSchedule ? modeToScheduleType(scheduleMode as ScheduleSlot) : null,
-        schedule_values: hasSchedule ? scheduleValues : null,
-        schedule_enabled: hasSchedule,
-        requires_confirmation: hasSchedule ? requiresConfirmation : false,
+        schedule_type: scheduleType,
+        schedule_values: scheduleValues.length > 0 ? scheduleValues : null,
+        schedule_enabled: scheduleMode !== "ondemand" && scheduleEnabled,
+        requires_confirmation: modeIsScheduled ? requiresConfirmation : false,
         yolo_mode: yoloMode,
         foreground_mode: foregroundMode,
         command: modeIsCommand ? command : "",
@@ -235,7 +257,9 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
       }
       if (!isEdit) localStorage.setItem("palmier:lastAgent", agent);
 
-      // Reactive on create: save the task, then start it and navigate to the run.
+      // Command-triggered on create: save the task, then start it and navigate
+      // to the run. Event-triggered tasks are started by the daemon in response
+      // to the next NATS event, so we just save.
       if (modeIsCommand && !isEdit) {
         onSaved(result);
         try {
@@ -257,7 +281,7 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
   const saveButtonLabel = (() => {
     if (isEdit) return "Save";
     if (modeIsCommand) return "Run";
-    if (modeIsScheduled) return "Schedule";
+    if ((modeIsScheduled || modeIsEvent) && scheduleEnabled) return "Schedule";
     return "Save";
   })();
 
@@ -325,18 +349,6 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
         </div>
 
         <div className="toggles-group">
-        {hostPlatform === "win32" && (
-          <label className="toggle-label">
-            <input
-              type="checkbox"
-              checked={foregroundMode}
-              onChange={(e) => setForegroundMode(e.target.checked)}
-              disabled={saving}
-            />
-            Run in the foreground (host must login to Windows)
-          </label>
-        )}
-
         <div className="schedule-section">
           <h3 className="schedule-section-title">Schedule</h3>
           <select
@@ -351,9 +363,22 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
             <option value="daily">Daily</option>
             <option value="weekly">Weekly</option>
             <option value="monthly">Monthly</option>
+            <option value="on_new_notification">On New Push Notification</option>
+            <option value="on_new_sms">On New SMS</option>
             <option value="command">Command-triggered</option>
           </select>
 
+          {modeIsEvent && (
+            <div className="schedule-reactive">
+              <p className="command-help-text">
+                {scheduleMode === "on_new_notification"
+                  ? "Runs each time a new notification arrives on the paired Android device."
+                  : "Runs each time a new SMS arrives on the paired Android device."}
+                {" "}The triggering payload is spliced into your task prompt — reference it as &ldquo;the new {scheduleMode === "on_new_notification" ? "notification" : "SMS"}&rdquo;.
+              </p>
+            </div>
+          )}
+
           {modeIsCommand && (
             <div className="schedule-reactive">
               <p className="command-help-text">
@@ -461,6 +486,17 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
             </>
           )}
 
+          {hostPlatform === "win32" && (
+            <label className="toggle-label">
+              <input
+                type="checkbox"
+                checked={foregroundMode}
+                onChange={(e) => setForegroundMode(e.target.checked)}
+                disabled={saving}
+              />
+              Run in the foreground (host must login to Windows)
+            </label>
+          )}
           {modeIsScheduled && (
             <label className="toggle-label">
               <input
@@ -472,6 +508,17 @@ export default function TaskForm({ initial, agents, hostPlatform, onSaved, onRun
               Confirm before each run
             </label>
           )}
+          {scheduleMode !== "ondemand" && (
+            <label className="toggle-label">
+              <input
+                type="checkbox"
+                checked={scheduleEnabled}
+                onChange={(e) => setScheduleEnabled(e.target.checked)}
+                disabled={saving}
+              />
+              Enabled
+            </label>
+          )}
         </div>
         </div>
 

package/palmier-server/pwa/src/components/TasksView.tsx

@@ -122,6 +122,11 @@ export default function TasksView({ connected, hostId, request, subscribeEvents,
             </div>
           ))}
         </div>
+      ) : tasks.length === 0 ? (
+        <div className="empty-state">
+          <p className="empty-state-text">No tasks yet</p>
+          <p className="empty-state-hint">Tap the + button to create your first task.</p>
+        </div>
       ) : (
         <div className="task-list">
           {tasks.map((task) => (

package/palmier-server/pwa/src/constants.ts

@@ -1,2 +1,2 @@
 /** Bump when a breaking host change is made. */
-export const MIN_HOST_VERSION = "0.7.8";
+export const MIN_HOST_VERSION = "0.8.0";

package/palmier-server/pwa/src/native/Device.ts

@@ -0,0 +1,48 @@
+import { Capacitor, registerPlugin, type PluginListenerHandle } from "@capacitor/core";
+
+export type PermissionType =
+  | "location"
+  | "sms"
+  | "contacts"
+  | "calendar"
+  | "notificationListener"
+  | "dnd"
+  | "fullScreenIntent";
+
+export interface PermissionResult {
+  granted: boolean;
+  /**
+   * False when the native build doesn't recognize this permission type — the PWA
+   * is served remotely and may ship ahead of the installed APK. Callers should
+   * treat unsupported types as "cannot enable" rather than as a hard error.
+   */
+  supported: boolean;
+}
+
+export interface DeepLinkEvent {
+  path: string;
+}
+
+interface DevicePlugin {
+  getFcmToken(): Promise<{ token: string }>;
+  /** Returns the set of PermissionType strings this native build understands. */
+  getSupportedPermissions(): Promise<{ types: PermissionType[] }>;
+  checkPermission(opts: { type: PermissionType }): Promise<PermissionResult>;
+  requestPermission(opts: { type: PermissionType }): Promise<PermissionResult>;
+  /**
+   * Authoritative list of capabilities the user has enabled on this device.
+   * Native receivers + handlers consult this as a local kill-switch. Unknown
+   * capability names are stored but ignored — safe for PWAs that ship new caps
+   * ahead of the installed APK.
+   */
+  setEnabledCapabilities(opts: { capabilities: string[] }): Promise<void>;
+  addListener(
+    event: "deepLink",
+    handler: (ev: DeepLinkEvent) => void
+  ): Promise<PluginListenerHandle>;
+}
+
+/** Null on web — callers must guard with Capacitor.isNativePlatform(). */
+export const Device = Capacitor.isNativePlatform()
+  ? registerPlugin<DevicePlugin>("Device")
+  : null;

package/palmier-server/pwa/src/pages/PairHost.tsx

@@ -4,6 +4,7 @@ import { connect, jwtAuthenticator, StringCodec } from "nats.ws";
 import { Capacitor } from "@capacitor/core";
 import { Preferences } from "@capacitor/preferences";
 import { useHostStore } from "../contexts/HostStoreContext";
+import { Device } from "../native/Device";
 import { SERVER_URL } from "../api";
 import type { PairedHost } from "../types";
 
@@ -85,9 +86,24 @@ export default function PairHost() {
 
       addPairedHost(host);
 
-      // Write hostId to native SharedPreferences for FCM token registration
-      if (Capacitor.isNativePlatform()) {
+      if (Capacitor.isNativePlatform() && Device) {
+        // Native receivers (SmsBroadcastReceiver, DeviceNotificationListenerService)
+        // read hostId to address relay messages.
         await Preferences.set({ key: "hostId", value: response.hostId });
+
+        // Register this device's FCM token with the relay server so it can wake
+        // the device on the paired host's behalf. Moved here from native so the
+        // APK no longer needs to read hostId or trigger registration itself.
+        try {
+          const { token: fcmToken } = await Device.getFcmToken();
+          await fetch(`${SERVER_URL}/api/fcm/register`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ hostId: response.hostId, fcmToken }),
+          });
+        } catch (err) {
+          console.warn("FCM token registration failed:", err);
+        }
       }
 
       navigate("/");

package/palmier-server/pwa/src/types.ts

@@ -11,7 +11,7 @@ export interface Task {
   name: string;
   user_prompt: string;
   agent?: string;
-  schedule_type?: "crons" | "specific_times";
+  schedule_type?: "crons" | "specific_times" | "on_new_notification" | "on_new_sms";
   schedule_values?: string[];
   schedule_enabled: boolean;
   requires_confirmation: boolean;

package/palmier-server/spec.md

@@ -223,7 +223,14 @@ requires_confirmation: true
 ---
 ```
 
-`schedule_type` is either `"crons"` (cron expressions) or `"specific_times"` (local datetime strings like `"2026-04-20T09:00"`). `schedule_values` is a homogeneous array whose elements match the type. Both fields are present together or absent together; absence means the task has no schedule and can only be run manually.
+`schedule_type` is one of:
+
+* `"crons"` — `schedule_values` holds cron expressions.
+* `"specific_times"` — `schedule_values` holds local datetime strings (e.g. `"2026-04-20T09:00"`).
+* `"on_new_notification"` — fires once per new Android notification relayed over NATS. No `schedule_values`.
+* `"on_new_sms"` — fires once per new SMS relayed over NATS. No `schedule_values`.
+
+For `crons` / `specific_times` the schedule is installed as an OS timer (systemd / Task Scheduler). For the `on_new_*` types the `palmier run` process subscribes directly to the corresponding NATS subject (`host.<hostId>.device.notifications` or `...device.sms`), drains events through a bounded FIFO queue, and invokes the agent once per event with the event payload spliced into the user prompt (mirroring command-triggered mode). These event-driven tasks are not started on save — they launch via `task.run` (the PWA auto-runs them on create, matching command-triggered UX).
 
 The `name` field is auto-generated by spawning the configured agent CLI with a short prompt (for prompts > 50 chars). For shorter prompts, the `user_prompt` is used directly as the name.
 
@@ -236,6 +243,7 @@ The optional `command` field stores a shell command for command-triggered tasks.
 * **`schedule_enabled`:** Controls whether systemd timers are installed for the task's schedule. When `false`, all timers are removed; when toggled back to `true`, timers are reinstalled. Defaults to `true`. The task can still be run manually via "Run Now" regardless of this setting. The "Enable Schedule" checkbox only appears in the UI when the task has a schedule.
 * **`crons` schedules:** Persist indefinitely. The systemd timer remains active until the task is deleted or the schedule is disabled.
 * **`specific_times` schedules:** After a value fires, it is removed from `schedule_values` and its corresponding systemd timer/service files are cleaned up. Once all values have fired the schedule is cleared, and the task remains in the `tasks/` directory as a manual task (can still be executed on-demand via the PWA or CLI, but will not fire automatically again).
+* **`on_new_notification` / `on_new_sms` schedules:** No OS timers are installed. Instead, the serve daemon subscribes to the matching NATS subject (`host.<host_id>.device.notifications` / `.sms`), maintains a per-task in-memory FIFO queue (max 100 entries; overflow drops the oldest), and spawns `palmier run <id>` via the OS scheduler when the task transitions from idle to active (tracked by an `active_run` flag flipped atomically on the empty-pop). The run process drains the queue by calling `POST /task-event/pop?taskId=<id>` on the localhost daemon: each non-empty response is spliced into the user prompt (`user_prompt + "\n\nProcess this new notification:\n" + <raw JSON payload>` or `...new SMS...`) and invoked through the standard agent retry loop. When the endpoint returns `{ empty: true }` the active flag is cleared and the run exits; the next incoming NATS event will start a fresh run. These tasks are never auto-run on save — they launch only in response to NATS events. Requires server mode (NATS).
 
 ### Task Events
 
@@ -305,7 +313,7 @@ Dashboard owns the always-on NATS event subscription and renders pending `confir
 
 4. For updates: if the user changes the `user_prompt` or `agent`, the name is regenerated. If neither changed, the existing name is preserved. Existing tasks with granted permissions show a clickable "Granted Permissions" link to view them.
 
-5. PWA sends `task.create` (or `task.update` with `id`) with the task fields as the message body. The `id` field is **not sent on create** — the host generates a UUID. `schedule_type` and `schedule_values` are omitted when the task has no schedule.
+5. PWA sends `task.create` (or `task.update` with `id`) with the task fields as the message body. The `id` field is **not sent on create** — the host generates a UUID. `schedule_type` and `schedule_values` are omitted when the task has no schedule; `schedule_values` is also omitted for the `on_new_notification` / `on_new_sms` types.
 
 6. Host creates/updates the `tasks/<task-id>/TASK.md` file and returns the **full flat task object** (all frontmatter fields at the top level). The PWA uses this response directly to update the UI.
 
@@ -407,6 +415,8 @@ The serve daemon exposes localhost-only HTTP endpoints that agents call during t
 
 * **`POST /request-permission`** — Requests permission grants. Body: `{ taskId, taskName, permissions }`. Called by `palmier run` (not agents). Returns `{ response: "granted" | "granted_all" | "aborted" }`.
 
+* **`POST /task-event/pop?taskId=<id>`** — Drains one queued event for an event-triggered task. Called by `palmier run` (not agents). Atomically: if the task's in-memory FIFO queue is non-empty, returns `{ event: "<raw JSON payload>" }` and keeps `active_run = true`; if empty, clears `active_run` and returns `{ empty: true }`. Used only for `schedule_type: "on_new_notification" | "on_new_sms"` tasks.
+
 ### 6.2 Resource Endpoints
 
 Resource REST endpoints are auto-generated from the `ResourceDefinition[]` registry in `mcp-tools.ts`. Each resource exposes a GET endpoint at its `restPath`. These are also available via the MCP protocol (`resources/list`, `resources/read`).

package/src/device-capabilities.ts

@@ -17,7 +17,7 @@ export type DeviceCapability =
   | "calendar"
   | "alert"
   | "battery"
-  | "email"
+  | "send-email"
   | "dnd";
 
 type CapabilityMap = Partial<Record<DeviceCapability, RegisteredDevice>>;

package/src/mcp-tools.ts

@@ -687,8 +687,8 @@ const sendEmailTool: ToolDefinition = {
   async handler(args, ctx) {
     if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
 
-    const device = getCapabilityDevice("email");
-    if (!device) throw new ToolError("No device has email access enabled", 400);
+    const device = getCapabilityDevice("send-email");
+    if (!device) throw new ToolError("No device has send-email access enabled", 400);
 
     const { to, subject, body, cc, bcc } = args as { to: string; subject?: string; body?: string; cc?: string; bcc?: string };
     if (!to) throw new ToolError("to is required", 400);

package/src/rpc-handler.ts

@@ -163,8 +163,8 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         // is active. Includes any prompts already waiting so a reconnecting
         // PWA can render their modals without replaying events.
         const capabilities: Record<string, string | null> = {};
-        for (const cap of ["location", "notifications", "sms", "contacts", "calendar", "alert", "battery", "dnd", "email"] as const) {
-          capabilities[cap] = getCapabilityDevice(cap)?.clientToken ?? null;
+        for (const capability of ["location", "notifications", "sms", "contacts", "calendar", "alert", "battery", "dnd", "send-email"] as const) {
+          capabilities[capability] = getCapabilityDevice(capability)?.clientToken ?? null;
         }
         return {
           agents: config.agents ?? [],