palmier 0.7.9 → 0.8.0

package/dist/commands/run.js

@@ -209,6 +209,15 @@ export async function runCommand(taskId) {
             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, {
@@ -380,6 +389,52 @@ async function runCommandTriggeredMode(ctx) {
     }
     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) {
+    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();
+            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 = {
+                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, config, taskDir, taskId, eventType, taskName, runId) {
     writeTaskStatus(taskDir, {
         running_state: eventType,

package/dist/commands/serve.js

@@ -14,6 +14,7 @@ import { CONFIG_DIR } from "../config.js";
 import { StringCodec } 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");
 /**
@@ -119,28 +120,47 @@ export async function serveCommand() {
         startNatsTransport(config, handleRpc, nc);
         // 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, payload) {
+            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/dist/event-queues.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+/**
+ * Queue a raw (JSON-string) event payload for a task. Returns whether the
+ * caller should now start the run process.
+ */
+export declare function enqueueEvent(taskId: string, payload: string): {
+    shouldStart: boolean;
+};
+/**
+ * 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 declare function popEvent(taskId: string): {
+    event: string;
+} | {
+    empty: true;
+};
+/** Remove any state for a task (called from task.delete). */
+export declare function clearTaskQueue(taskId: string): void;
+//# sourceMappingURL=event-queues.d.ts.map

package/dist/event-queues.js

@@ -0,0 +1,53 @@
+/**
+ * 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();
+const activeRuns = new Set();
+/**
+ * Queue a raw (JSON-string) event payload for a task. Returns whether the
+ * caller should now start the run process.
+ */
+export function enqueueEvent(taskId, payload) {
+    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) {
+    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) {
+    queues.delete(taskId);
+    activeRuns.delete(taskId);
+}
+//# sourceMappingURL=event-queues.js.map

package/dist/platform/windows.js

@@ -177,11 +177,14 @@ export class WindowsPlatform {
         const tn = schtasksTaskName(taskId);
         const script = process.argv[1] || "palmier";
         const tr = `"${process.execPath}" "${script}" run ${taskId}`;
-        // Build trigger XML elements
+        // Build trigger XML elements. Event-based schedule types (on_new_notification,
+        // on_new_sms) carry no values and are driven by the run process, not the OS
+        // scheduler — they intentionally produce only the dummy trigger below.
         const triggerElements = [];
         const scheduleType = task.frontmatter.schedule_type;
         const scheduleValues = task.frontmatter.schedule_values;
-        if (task.frontmatter.schedule_enabled && scheduleType && scheduleValues?.length) {
+        const isTimerSchedule = scheduleType === "crons" || scheduleType === "specific_times";
+        if (task.frontmatter.schedule_enabled && isTimerSchedule && scheduleValues?.length) {
             for (const value of scheduleValues) {
                 try {
                     triggerElements.push(scheduleValueToXml(scheduleType, value));

package/dist/rpc-handler.js

@@ -13,6 +13,7 @@ import { publishHostEvent } from "./events.js";
 import { getCapabilityDevice, setCapabilityDevice, clearCapabilityDevice } from "./device-capabilities.js";
 import { currentVersion, performUpdate } from "./update-checker.js";
 import { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
+import { clearTaskQueue } from "./event-queues.js";
 /**
  * Parse RESULT frontmatter and conversation messages.
  */
@@ -142,7 +143,7 @@ export function createRpcHandler(config, nc) {
                 // is active. Includes any prompts already waiting so a reconnecting
                 // PWA can render their modals without replaying events.
                 const capabilities = {};
-                for (const cap of ["location", "notifications", "sms", "contacts", "calendar", "alert", "battery", "dnd"]) {
+                for (const cap of ["location", "notifications", "sms", "contacts", "calendar", "alert", "battery", "dnd", "email"]) {
                     capabilities[cap] = getCapabilityDevice(cap)?.clientToken ?? null;
                 }
                 return {
@@ -183,9 +184,8 @@ export function createRpcHandler(config, nc) {
                         agent: params.agent,
                         schedule_enabled: params.schedule_enabled ?? true,
                         requires_confirmation: params.requires_confirmation ?? true,
-                        ...(params.schedule_type && params.schedule_values?.length
-                            ? { schedule_type: params.schedule_type, schedule_values: params.schedule_values }
-                            : {}),
+                        ...(params.schedule_type ? { schedule_type: params.schedule_type } : {}),
+                        ...(params.schedule_values?.length ? { schedule_values: params.schedule_values } : {}),
                         ...(params.yolo_mode ? { yolo_mode: true } : {}),
                         ...(params.foreground_mode ? { foreground_mode: true } : {}),
                         ...(params.command ? { command: params.command } : {}),
@@ -258,6 +258,7 @@ export function createRpcHandler(config, nc) {
             case "task.delete": {
                 const params = request.params;
                 getPlatform().removeTaskTimer(params.id);
+                clearTaskQueue(params.id);
                 removeFromTaskList(config.projectRoot, params.id);
                 return { ok: true, task_id: params.id };
             }

package/dist/transports/http-transport.js

@@ -8,6 +8,7 @@ import * as fs from "node:fs";
 import { agentToolMap, agentResources, ToolError } from "../mcp-tools.js";
 import { handleMcpRequest, getAgentName, getResourceSubscriptions } from "../mcp-handler.js";
 import { getTaskDir } from "../task.js";
+import { popEvent } from "../event-queues.js";
 const assetCache = new Map();
 const PWA_DIR = path.join(import.meta.dirname, "..", "pwa");
 const CONTENT_TYPES = {
@@ -247,6 +248,20 @@ export async function startHttpTransport(config, handleRpc, port, nc, pairingCod
             sendJson(res, 200, result);
             return;
         }
+        // ── Event queue pop (used by event-triggered palmier run) ─────────
+        if (req.method === "POST" && pathname === "/task-event/pop") {
+            if (!isLocalhost(req)) {
+                sendJson(res, 403, { error: "localhost only" });
+                return;
+            }
+            const taskId = url.searchParams.get("taskId");
+            if (!taskId) {
+                sendJson(res, 400, { error: "taskId query parameter is required" });
+                return;
+            }
+            sendJson(res, 200, popEvent(taskId));
+            return;
+        }
         // ── Localhost-only endpoints (no auth) ─────────────────────────────
         if (req.method === "POST" && pathname === "/event") {
             if (!isLocalhost(req)) {

package/dist/types.d.ts

@@ -20,12 +20,13 @@ export interface TaskFrontmatter {
     user_prompt: string;
     agent: string;
     /**
-     * Task schedule. `schedule_values` is homogeneous per `schedule_type`:
-     * - `crons`: array of cron expressions (e.g. "0 9 * * *")
-     * - `specific_times`: array of local datetime strings (e.g. "2026-04-20T09:00")
-     * Both fields are present together or absent together.
+     * Task schedule.
+     * - `crons`: `schedule_values` holds cron expressions (e.g. "0 9 * * *")
+     * - `specific_times`: `schedule_values` holds local datetime strings (e.g. "2026-04-20T09:00")
+     * - `on_new_notification`: fires on each new Android notification from NATS; no `schedule_values`
+     * - `on_new_sms`: fires on each new SMS from NATS; no `schedule_values`
      */
-    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palmier",
-  "version": "0.7.9",
+  "version": "0.8.0",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
   "license": "Apache-2.0",
   "author": "Hongxu Cai",

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/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);
+}

package/src/platform/windows.ts

@@ -192,11 +192,14 @@ export class WindowsPlatform implements PlatformService {
     const script = process.argv[1] || "palmier";
     const tr = `"${process.execPath}" "${script}" run ${taskId}`;
 
-    // Build trigger XML elements
+    // Build trigger XML elements. Event-based schedule types (on_new_notification,
+    // on_new_sms) carry no values and are driven by the run process, not the OS
+    // scheduler — they intentionally produce only the dummy trigger below.
     const triggerElements: string[] = [];
     const scheduleType = task.frontmatter.schedule_type;
     const scheduleValues = task.frontmatter.schedule_values;
-    if (task.frontmatter.schedule_enabled && scheduleType && scheduleValues?.length) {
+    const isTimerSchedule = scheduleType === "crons" || scheduleType === "specific_times";
+    if (task.frontmatter.schedule_enabled && isTimerSchedule && scheduleValues?.length) {
       for (const value of scheduleValues) {
         try {
           triggerElements.push(scheduleValueToXml(scheduleType, value));

package/src/rpc-handler.ts

@@ -14,6 +14,7 @@ import { publishHostEvent } from "./events.js";
 import { getCapabilityDevice, setCapabilityDevice, clearCapabilityDevice, type DeviceCapability } from "./device-capabilities.js";
 import { currentVersion, performUpdate } from "./update-checker.js";
 import { parseReportFiles, parseTaskOutcome, stripPalmierMarkers } from "./commands/run.js";
+import { clearTaskQueue } from "./event-queues.js";
 import type { HostConfig, ParsedTask, RpcMessage, ConversationMessage } from "./types.js";
 
 /**
@@ -162,7 +163,7 @@ 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"] as const) {
+        for (const cap of ["location", "notifications", "sms", "contacts", "calendar", "alert", "battery", "dnd", "email"] as const) {
           capabilities[cap] = getCapabilityDevice(cap)?.clientToken ?? null;
         }
         return {
@@ -194,7 +195,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const params = request.params as {
           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;
@@ -217,9 +218,8 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
             agent: params.agent,
             schedule_enabled: params.schedule_enabled ?? true,
             requires_confirmation: params.requires_confirmation ?? true,
-            ...(params.schedule_type && params.schedule_values?.length
-              ? { schedule_type: params.schedule_type, schedule_values: params.schedule_values }
-              : {}),
+            ...(params.schedule_type ? { schedule_type: params.schedule_type } : {}),
+            ...(params.schedule_values?.length ? { schedule_values: params.schedule_values } : {}),
             ...(params.yolo_mode ? { yolo_mode: true } : {}),
             ...(params.foreground_mode ? { foreground_mode: true } : {}),
             ...(params.command ? { command: params.command } : {}),
@@ -238,7 +238,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           id: string;
           user_prompt?: string;
           agent?: string;
-          schedule_type?: "crons" | "specific_times" | null;
+          schedule_type?: "crons" | "specific_times" | "on_new_notification" | "on_new_sms" | null;
           schedule_values?: string[] | null;
           schedule_enabled?: boolean;
           requires_confirmation?: boolean;
@@ -307,6 +307,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const params = request.params as { id: string };
 
         getPlatform().removeTaskTimer(params.id);
+        clearTaskQueue(params.id);
         removeFromTaskList(config.projectRoot, params.id);
 
         return { ok: true, task_id: params.id };

package/src/transports/http-transport.ts

@@ -9,6 +9,7 @@ import type { HostConfig, RpcMessage, RequiredPermission } from "../types.js";
 import { agentToolMap, agentResources, ToolError, type ToolContext } from "../mcp-tools.js";
 import { handleMcpRequest, getAgentName, getResourceSubscriptions } from "../mcp-handler.js";
 import { getTaskDir } from "../task.js";
+import { popEvent } from "../event-queues.js";
 
 // ── Bundled PWA asset serving ───────────────────────────────────────────
 
@@ -279,6 +280,19 @@ export async function startHttpTransport(
       return;
     }
 
+    // ── Event queue pop (used by event-triggered palmier run) ─────────
+
+    if (req.method === "POST" && pathname === "/task-event/pop") {
+      if (!isLocalhost(req)) { sendJson(res, 403, { error: "localhost only" }); return; }
+      const taskId = url.searchParams.get("taskId");
+      if (!taskId) {
+        sendJson(res, 400, { error: "taskId query parameter is required" });
+        return;
+      }
+      sendJson(res, 200, popEvent(taskId));
+      return;
+    }
+
     // ── Localhost-only endpoints (no auth) ─────────────────────────────
 
     if (req.method === "POST" && pathname === "/event") {

package/src/types.ts

@@ -22,12 +22,13 @@ export interface TaskFrontmatter {
   user_prompt: string;
   agent: string;
   /**
-   * Task schedule. `schedule_values` is homogeneous per `schedule_type`:
-   * - `crons`: array of cron expressions (e.g. "0 9 * * *")
-   * - `specific_times`: array of local datetime strings (e.g. "2026-04-20T09:00")
-   * Both fields are present together or absent together.
+   * Task schedule.
+   * - `crons`: `schedule_values` holds cron expressions (e.g. "0 9 * * *")
+   * - `specific_times`: `schedule_values` holds local datetime strings (e.g. "2026-04-20T09:00")
+   * - `on_new_notification`: fires on each new Android notification from NATS; no `schedule_values`
+   * - `on_new_sms`: fires on each new SMS from NATS; no `schedule_values`
    */
-  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;