palmier 0.7.9 → 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/commands/run.ts

@@ -267,6 +267,14 @@ export async function runCommand(taskId: string): Promise<void> {
       appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
       await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
       console.log(`Task ${taskId} completed (command-triggered).`);
+    } else if (task.frontmatter.schedule_type === "on_new_notification"
+               || task.frontmatter.schedule_type === "on_new_sms") {
+      // Event-triggered mode (driven by NATS pub/sub of device notifications/SMS)
+      const result = await runEventTriggeredMode(ctx);
+      const outcome = resolveOutcome(taskDir, result.outcome);
+      appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
+      await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
+      console.log(`Task ${taskId} completed (event-triggered).`);
     } else {
       // Standard execution — add user prompt as first message
       await appendAndNotify(ctx, {
@@ -455,6 +463,59 @@ async function runCommandTriggeredMode(
   return { outcome: "finished", endTime };
 }
 
+/**
+ * Event-triggered execution mode.
+ *
+ * Drains the daemon-owned per-task event queue via the local /task-event/pop
+ * HTTP endpoint, invoking the agent once per event with the payload spliced
+ * into the user prompt. The run process itself holds no NATS subscription;
+ * the daemon handles that and atomically clears the active flag when we see
+ * an empty pop, so it can fire up a fresh run on the next incoming event.
+ */
+async function runEventTriggeredMode(
+  ctx: InvocationContext,
+): Promise<{ outcome: TaskRunningState; endTime: number }> {
+  const scheduleType = ctx.task.frontmatter.schedule_type!;
+  const label = scheduleType === "on_new_notification" ? "notification" : "SMS";
+  const port = ctx.config.httpPort ?? 7256;
+  const popUrl = `http://localhost:${port}/task-event/pop?taskId=${encodeURIComponent(ctx.taskId)}`;
+
+  console.log(`[event-triggered] Draining ${label} queue`);
+  appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "monitoring" });
+  await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+
+  let eventsProcessed = 0;
+  try {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const res = await fetch(popUrl, { method: "POST" });
+      if (!res.ok) throw new Error(`pop-event failed: ${res.status} ${res.statusText}`);
+      const body = await res.json() as { event?: string; empty?: true };
+      if (body.empty || !body.event) break;
+
+      eventsProcessed++;
+      console.log(`[event-triggered] Processing ${label} #${eventsProcessed}`);
+
+      const perEventPrompt = `${ctx.task.frontmatter.user_prompt}\n\nProcess this new ${label}:\n${body.event}`;
+      const perEventTask: ParsedTask = {
+        frontmatter: { ...ctx.task.frontmatter, user_prompt: perEventPrompt },
+      };
+
+      await invokeAgentWithRetries(ctx, perEventTask);
+
+      appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "monitoring" });
+      await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: errorMsg, type: "error" });
+    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+    return { outcome: "failed", endTime: Date.now() };
+  }
+
+  return { outcome: "finished", endTime: Date.now() };
+}
+
 async function publishTaskEvent(
   nc: NatsConnection | undefined,
   config: HostConfig,

package/src/commands/serve.ts

@@ -15,6 +15,7 @@ import { CONFIG_DIR } from "../config.js";
 import { StringCodec, type NatsConnection } from "nats";
 import { addNotification } from "../notification-store.js";
 import { addSmsMessage } from "../sms-store.js";
+import { enqueueEvent } from "../event-queues.js";
 
 const POLL_INTERVAL_MS = 30_000;
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
@@ -135,27 +136,46 @@ export async function serveCommand(): Promise<void> {
 
     // Subscribe to device notifications and SMS from Android
     const sc = StringCodec();
+
+    // Dispatch a raw event payload to every task whose schedule matches.
+    function dispatchDeviceEvent(scheduleType: "on_new_notification" | "on_new_sms", payload: string): void {
+      for (const task of listTasks(config.projectRoot)) {
+        if (task.frontmatter.schedule_type !== scheduleType) continue;
+        if (!task.frontmatter.schedule_enabled) continue;
+        const { shouldStart } = enqueueEvent(task.frontmatter.id, payload);
+        if (shouldStart) {
+          platform.startTask(task.frontmatter.id).catch((err) => {
+            console.error(`[event-trigger] Failed to start ${task.frontmatter.id}:`, err);
+          });
+        }
+      }
+    }
+
     const notifSub = nc.subscribe(`host.${config.hostId}.device.notifications`);
     (async () => {
       for await (const msg of notifSub) {
+        const raw = sc.decode(msg.data);
         try {
-          const data = JSON.parse(sc.decode(msg.data));
+          const data = JSON.parse(raw);
           addNotification({ ...data, receivedAt: Date.now() });
         } catch (err) {
           console.error("[nats] Failed to parse device notification:", err);
         }
+        dispatchDeviceEvent("on_new_notification", raw);
       }
     })();
 
     const smsSub = nc.subscribe(`host.${config.hostId}.device.sms`);
     (async () => {
       for await (const msg of smsSub) {
+        const raw = sc.decode(msg.data);
         try {
-          const data = JSON.parse(sc.decode(msg.data));
+          const data = JSON.parse(raw);
           addSmsMessage({ ...data, receivedAt: Date.now() });
         } catch (err) {
           console.error("[nats] Failed to parse device SMS:", err);
         }
+        dispatchDeviceEvent("on_new_sms", raw);
       }
     })();
   }

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/event-queues.ts

@@ -0,0 +1,56 @@
+/**
+ * Per-task in-memory event queues for event-triggered schedules
+ * (schedule_type: "on_new_notification" | "on_new_sms").
+ *
+ * The daemon owns the NATS subscription and populates these queues; the
+ * `palmier run` process drains them via the localhost /task-event/pop HTTP
+ * endpoint. `activeRuns` tracks whether a run process is currently draining,
+ * so we don't race a fresh startTask with a teardown-phase run.
+ *
+ * Lifecycle invariants:
+ *   - activeRuns is cleared atomically inside popEvent when the queue is
+ *     drained. At that point the calling run has already finished its last
+ *     agent invocation and is only tearing down.
+ *   - enqueueEvent returns shouldStart=true only if the task transitioned
+ *     from idle (no active run) to active — callers must then startTask.
+ */
+
+const MAX_QUEUE_SIZE = 100;
+
+const queues = new Map<string, string[]>();
+const activeRuns = new Set<string>();
+
+/**
+ * Queue a raw (JSON-string) event payload for a task. Returns whether the
+ * caller should now start the run process.
+ */
+export function enqueueEvent(taskId: string, payload: string): { shouldStart: boolean } {
+  const queue = queues.get(taskId) ?? [];
+  if (queue.length >= MAX_QUEUE_SIZE) queue.shift();
+  queue.push(payload);
+  queues.set(taskId, queue);
+
+  if (activeRuns.has(taskId)) return { shouldStart: false };
+  activeRuns.add(taskId);
+  return { shouldStart: true };
+}
+
+/**
+ * Pop the oldest queued event for a task. Returns `{ event }` when one is
+ * available (keeps the task marked active), or `{ empty: true }` after
+ * clearing the active flag atomically.
+ */
+export function popEvent(taskId: string): { event: string } | { empty: true } {
+  const queue = queues.get(taskId);
+  if (queue && queue.length > 0) {
+    return { event: queue.shift()! };
+  }
+  activeRuns.delete(taskId);
+  return { empty: true };
+}
+
+/** Remove any state for a task (called from task.delete). */
+export function clearTaskQueue(taskId: string): void {
+  queues.delete(taskId);
+  activeRuns.delete(taskId);
+}