palmier 0.7.8 → 0.8.0

package/palmier-server/pwa/src/components/{TaskListView.tsx → TasksView.tsx}

@@ -1,9 +1,11 @@
 import { useState, useEffect, useCallback } from "react";
 import TaskCard from "./TaskCard";
 import TaskForm from "./TaskForm";
+import PullToRefreshIndicator from "./PullToRefreshIndicator";
+import { usePullToRefresh } from "../hooks/usePullToRefresh";
 import type { AgentInfo, Task, TaskStatus } from "../types";
 
-interface TaskListViewProps {
+interface TasksViewProps {
   connected: boolean;
   hostId: string | null;
   request<T = unknown>(method: string, params?: unknown, opts?: { timeout?: number }): Promise<T>;
@@ -13,7 +15,7 @@ interface TaskListViewProps {
   onViewRun(taskId: string, runId?: string): void;
 }
 
-export default function TaskListView({ connected, hostId, request, subscribeEvents, agents, hostPlatform, onViewRun }: TaskListViewProps) {
+export default function TasksView({ connected, hostId, request, subscribeEvents, agents, hostPlatform, onViewRun }: TasksViewProps) {
   const [tasks, setTasks] = useState<Task[]>([]);
   const [loadingTasks, setLoadingTasks] = useState(false);
   const [taskError, setTaskError] = useState<string | null>(null);
@@ -55,6 +57,8 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
     else { setTasks([]); setLoadingTasks(false); }
   }, [connected, hostId, loadTasks]);
 
+  const ptr = usePullToRefresh({ onRefresh: loadTasks, enabled: connected });
+
   // While mounted, keep task-card state fresh by refetching task.status on
   // running-state / permission-resolved events. Dashboard owns the modal
   // subscription; this one only drives the card indicators.
@@ -98,19 +102,9 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
 
   return (
     <>
+      <PullToRefreshIndicator pullDistance={ptr.pullDistance} refreshing={ptr.refreshing} threshold={ptr.threshold} />
       {taskError && <div className="form-error">{taskError}{taskError.toLowerCase().includes("failed to fetch") && <>{" "}<a href="#" onClick={(e) => { e.preventDefault(); window.location.reload(); }}>Reload</a></>}</div>}
 
-      <div
-        className="new-task-input-card"
-        onClick={() => { setEditingTask(undefined); setShowForm(true); }}
-        role="button"
-        tabIndex={0}
-        onKeyDown={(e) => { if (e.key === "Enter" || e.key === " ") { setEditingTask(undefined); setShowForm(true); } }}
-      >
-        <span className="new-task-placeholder">Describe your new task...</span>
-      </div>
-
-
       {loadingTasks && !tasks.length ? (
         <div className="task-list">
           {[0, 1, 2].map((i) => (
@@ -151,12 +145,25 @@ export default function TaskListView({ connected, hostId, request, subscribeEven
         </div>
       )}
 
+      <button
+        className="fab"
+        onClick={() => { setEditingTask(undefined); setShowForm(true); }}
+        aria-label="New task"
+        title="New task"
+      >
+        <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
+          <line x1="12" y1="5" x2="12" y2="19" />
+          <line x1="5" y1="12" x2="19" y2="12" />
+        </svg>
+      </button>
+
       {showForm && (
         <TaskForm
           initial={editingTask}
           agents={agents}
           hostPlatform={hostPlatform}
           onSaved={handleTaskSaved}
+          onRun={onViewRun}
           onCancel={closeForm}
         />
       )}

package/palmier-server/pwa/src/contexts/HostStoreContext.tsx

@@ -88,17 +88,25 @@ export function HostStoreProvider({ children }: { children: ReactNode }) {
   }, []);
 
   const removePairedHost = useCallback((hostId: string) => {
-    setPairedHosts((prev) => {
-      const filtered = prev.filter((h) => h.hostId !== hostId);
-      if (filtered.length > 0) {
-        setActiveHostIdState(filtered[0].hostId);
-      } else {
-        setActiveHostIdState(null);
-      }
-      return filtered;
+    setPairedHosts((prev) => prev.filter((h) => h.hostId !== hostId));
+    // Only change the active host when the active one is the one being deleted.
+    setActiveHostIdState((current) => {
+      if (current !== hostId) return current;
+      // The deleted host was active; we'll re-select once pairedHosts settles.
+      return null;
     });
   }, []);
 
+  // When the active host disappears (e.g. it was just unpaired), fall back to
+  // any remaining paired host, otherwise null.
+  useEffect(() => {
+    if (activeHostId !== null && !pairedHosts.find((h) => h.hostId === activeHostId)) {
+      setActiveHostIdState(pairedHosts[0]?.hostId ?? null);
+    } else if (activeHostId === null && pairedHosts.length > 0) {
+      setActiveHostIdState(pairedHosts[0].hostId);
+    }
+  }, [pairedHosts, activeHostId]);
+
   const renamePairedHost = useCallback((hostId: string, name: string) => {
     setPairedHosts((prev) =>
       prev.map((h) => (h.hostId === hostId ? { ...h, name } : h))

package/palmier-server/pwa/src/hooks/usePullToRefresh.ts

@@ -0,0 +1,102 @@
+import { useEffect, useRef, useState } from "react";
+
+interface Options {
+  onRefresh: () => Promise<unknown> | void;
+  /** Pixels the user must pull past before a release triggers a refresh. */
+  threshold?: number;
+  /** Maximum visual pull distance after resistance dampening. */
+  maxPull?: number;
+  enabled?: boolean;
+}
+
+/**
+ * Window-level pull-to-refresh for the tasks/sessions lists. Activates only
+ * when the user starts a touch at `scrollY === 0` and drags downward.
+ * Returns `pullDistance` (dampened pixels to visually translate an indicator)
+ * and `refreshing` (true while the consumer's onRefresh promise is in flight).
+ */
+export function usePullToRefresh({
+  onRefresh,
+  threshold = 70,
+  maxPull = 110,
+  enabled = true,
+}: Options) {
+  const [pullDistance, setPullDistance] = useState(0);
+  const [refreshing, setRefreshing] = useState(false);
+
+  const startY = useRef<number | null>(null);
+  const pulling = useRef(false);
+  const distance = useRef(0);
+  const refreshingRef = useRef(false);
+  const onRefreshRef = useRef(onRefresh);
+  useEffect(() => { onRefreshRef.current = onRefresh; });
+
+  useEffect(() => {
+    if (!enabled) return;
+
+    const onTouchStart = (e: TouchEvent) => {
+      if (refreshingRef.current || window.scrollY > 0) {
+        startY.current = null;
+        return;
+      }
+      startY.current = e.touches[0].clientY;
+      pulling.current = false;
+      distance.current = 0;
+    };
+
+    const onTouchMove = (e: TouchEvent) => {
+      if (refreshingRef.current || startY.current == null) return;
+      const dy = e.touches[0].clientY - startY.current;
+      if (dy <= 0) {
+        pulling.current = false;
+        distance.current = 0;
+        setPullDistance(0);
+        return;
+      }
+      pulling.current = true;
+      const adjusted = Math.min(maxPull, dy * 0.5);
+      distance.current = adjusted;
+      setPullDistance(adjusted);
+      if (e.cancelable) e.preventDefault();
+    };
+
+    const onTouchEnd = () => {
+      if (!pulling.current) {
+        startY.current = null;
+        setPullDistance(0);
+        return;
+      }
+      const pulled = distance.current;
+      startY.current = null;
+      pulling.current = false;
+      distance.current = 0;
+      if (pulled >= threshold) {
+        refreshingRef.current = true;
+        setRefreshing(true);
+        setPullDistance(threshold);
+        Promise.resolve(onRefreshRef.current())
+          .catch(() => { /* swallow — indicator still closes */ })
+          .finally(() => {
+            refreshingRef.current = false;
+            setRefreshing(false);
+            setPullDistance(0);
+          });
+      } else {
+        setPullDistance(0);
+      }
+    };
+
+    window.addEventListener("touchstart", onTouchStart, { passive: true });
+    window.addEventListener("touchmove", onTouchMove, { passive: false });
+    window.addEventListener("touchend", onTouchEnd, { passive: true });
+    window.addEventListener("touchcancel", onTouchEnd, { passive: true });
+    return () => {
+      window.removeEventListener("touchstart", onTouchStart);
+      window.removeEventListener("touchmove", onTouchMove);
+      window.removeEventListener("touchend", onTouchEnd);
+      window.removeEventListener("touchcancel", onTouchEnd);
+    };
+  }, [enabled, threshold, maxPull]);
+
+  return { pullDistance, refreshing, threshold };
+}

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

@@ -4,10 +4,10 @@ import { useNavigate, useLocation, useParams } from "react-router-dom";
 
 import { useHostStore } from "../contexts/HostStoreContext";
 import { useHostConnection } from "../contexts/HostConnectionContext";
-import TaskListView from "../components/TaskListView";
+import TasksView from "../components/TasksView";
 import TabBar from "../components/TabBar";
 import HostMenu from "../components/HostMenu";
-import RunsView from "../components/RunsView";
+import SessionsView from "../components/SessionsView";
 import RunDetailView from "../components/RunDetailView";
 import { usePushSubscription } from "../hooks/usePushSubscription";
 import { useMediaQuery } from "../hooks/useMediaQuery";
@@ -54,26 +54,9 @@ export default function Dashboard() {
   const isTasksTab = location.pathname.startsWith("/tasks");
   const runsFilterTaskId = params.runId ? undefined : params.taskId;
 
-  // Resolve "latest" run ID to the actual run ID
-  const [resolvedRunId, setResolvedRunId] = useState<string | null>(null);
-  const rawRunId = params.runId;
-  const isLatest = rawRunId === "latest";
-
-  useEffect(() => {
-    if (!isLatest || !params.taskId || !connected) {
-      setResolvedRunId(null);
-      return;
-    }
-    request<{ entries?: Array<{ run_id: string }> }>("taskrun.list", { task_id: params.taskId, limit: 1 })
-      .then((result) => {
-        const latest = result.entries?.[0]?.run_id;
-        setResolvedRunId(latest ?? null);
-      })
-      .catch(() => setResolvedRunId(null));
-  }, [isLatest, params.taskId, connected]);
-
-  const effectiveRunId = isLatest ? resolvedRunId : rawRunId;
-  const isRunDetail = !!(params.taskId && effectiveRunId && effectiveRunId !== "latest");
+  // "latest" is passed through to RunDetailView, which does its own resolution
+  // and renders an empty state if the task has no runs.
+  const isRunDetail = !!(params.taskId && params.runId);
 
   const [updateRequired, setUpdateRequired] = useState(false);
   const [updating, setUpdating] = useState(false);
@@ -151,7 +134,7 @@ export default function Dashboard() {
   }, [connected, activeHostId, request]);
 
   // Always-on event subscription for modal lifecycle. Independent of which tab
-  // is active. Task-card status updates happen inside TaskListView while mounted.
+  // is active. Task-card status updates happen inside TasksView while mounted.
   useEffect(() => {
     if (!connected || !activeHostId) return;
     const unsubscribe = subscribeEvents(activeHostId, (msg) => {
@@ -353,7 +336,7 @@ export default function Dashboard() {
         ) : showTaskContent ? (
           <>
             {isTasksTab && !isRunDetail && (
-              <TaskListView
+              <TasksView
                 connected={connected}
                 hostId={activeHostId}
                 request={request}
@@ -370,10 +353,10 @@ export default function Dashboard() {
                 request={request}
                 subscribeEvents={subscribeEvents}
                 taskId={params.taskId!}
-                runId={decodeURIComponent(effectiveRunId!)}
+                runId={decodeURIComponent(params.runId!)}
               />
             ) : !isTasksTab ? (
-              <RunsView
+              <SessionsView
                 connected={connected}
                 hostId={activeHostId}
                 request={request}

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

@@ -1,8 +1,8 @@
 export interface AgentInfo {
   key: string;
   label: string;
-  supportsPermissions?: boolean;
-  supportsYolo?: boolean;
+  supportsPermissions: boolean;
+  supportsYolo: boolean;
 }
 
 
@@ -11,8 +11,9 @@ export interface Task {
   name: string;
   user_prompt: string;
   agent?: string;
-  triggers: Trigger[];
-  triggers_enabled: boolean;
+  schedule_type?: "crons" | "specific_times";
+  schedule_values?: string[];
+  schedule_enabled: boolean;
   requires_confirmation: boolean;
   yolo_mode?: boolean;
   foreground_mode?: boolean;
@@ -20,11 +21,6 @@ export interface Task {
   command?: string;
 }
 
-export interface Trigger {
-  type: "cron" | "once";
-  value: string;
-}
-
 export interface RequiredPermission {
   name: string;
   description: string;

package/palmier-server/spec.md

@@ -119,8 +119,8 @@ The **RPC method is derived from the NATS subject**, not the message body. The h
 | `host.info` | *(none)* | Bootstrap metadata fetched once per connection. Returns `{ agents, version, host_platform, capability_tokens, pending_prompts }`. `pending_prompts` is an array of prompts already waiting when the PWA reconnects (each `{ key, type, params?, meta? }`), so modals can render without replaying events. |
 | `task.list` | *(none)* | List all tasks with frontmatter, created_at, and current status. |
 | `task.get` | `id` | Get a single task with frontmatter and current status. |
-| `task.create` | `user_prompt`, `agent`, `triggers?`, `triggers_enabled?`, `requires_confirmation?`, `yolo_mode?`, `foreground_mode?`, `command?` | Create a new task with auto-generated name (30s timeout for prompts > 50 chars), install system timers if triggers present. |
-| `task.update` | `id`, `user_prompt?`, `agent?`, `triggers?`, `triggers_enabled?`, `requires_confirmation?`, `yolo_mode?`, `foreground_mode?`, `command?` | Update an existing task. Regenerates name if `user_prompt` or `agent` changed. Reinstall timers as needed. |
+| `task.create` | `user_prompt`, `agent`, `schedule_type?`, `schedule_values?`, `schedule_enabled?`, `requires_confirmation?`, `yolo_mode?`, `foreground_mode?`, `command?` | Create a new task with auto-generated name (30s timeout for prompts > 50 chars), install system timers if a schedule is present. |
+| `task.update` | `id`, `user_prompt?`, `agent?`, `schedule_type?`, `schedule_values?`, `schedule_enabled?`, `requires_confirmation?`, `yolo_mode?`, `foreground_mode?`, `command?` | Update an existing task. Regenerates name if `user_prompt` or `agent` changed. Reinstall timers as needed. Pass `null` for `schedule_type` or `schedule_values` to clear them. |
 | `task.delete` | `id` | Delete a task and its systemd timers |
 | `task.run` | `id` | Start a task via system scheduler (`systemctl --user start` / `schtasks /run`) |
 | `task.abort` | `id` | Stop a running task via system scheduler (`systemctl --user stop` / `schtasks /end`) |
@@ -215,27 +215,27 @@ Messages are appended incrementally during execution.
 id: "uuid-v4"
 user_prompt: "Run a system audit and summarize large files..."
 agent: "claude"
-triggers:
-  - type: "cron"
-    value: "0 9 * * 1"
-  - type: "once"
-    value: "2026-03-20T15:00:00Z"
-triggers_enabled: true
+schedule_type: "crons"
+schedule_values:
+  - "0 9 * * 1"
+schedule_enabled: true
 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.
+
 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.
 
 The `agent` field stores the agent name (e.g., `"claude"`, `"codex"`). The corresponding `AgentTool` implementation is responsible for constructing the full command and arguments at execution time.
 
 The optional `command` field stores a shell command for command-triggered tasks. When set, the task runs in command-triggered mode: the command is spawned with `shell: true`, and each line of its stdout triggers a separate agent invocation with `user_prompt + "\n\nProcess this input:\n" + line`.
 
-#### Trigger Lifecycle
+#### Schedule Lifecycle
 
-* **`triggers_enabled`:** Controls whether systemd timers are installed for the task's triggers. 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 Triggers" checkbox only appears in the UI when the task has at least one trigger.
-* **`cron` triggers:** Persist indefinitely. The systemd timer remains active until the task is deleted or triggers are disabled.
-* **`once` triggers:** After firing, the trigger is removed from the `TASK.md` frontmatter and its corresponding systemd timer/service files are cleaned up. The task itself 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).
+* **`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).
 
 ### Task Events
 
@@ -250,7 +250,7 @@ Task lifecycle status is persisted to a `status.json` file in the task directory
 
 The `task.list` RPC includes each task's current status (read from `status.json`). The `task.status` RPC returns the status for a single task.
 
-The PWA receives initial statuses from `task.list` on load. It subscribes to `host-event.<activeHostId>.>` for live updates; on each notification it parses the `event_type` field and calls the host's `task.status` RPC to fetch the current status. Task cards display the `user_prompt` as the title (truncated to 2 lines) and a status indicator: a marching dots animation when running (`started`), a red dot for errors (`aborted` or `failed`), a gray dot when triggers are disabled or absent, and a green dot when idle (no entry or `finished`). When the last run was successful (`finished`), a "View Result" button loads the task's result file in a popup dialog. The "once" trigger date/time picker only allows selecting future dates and times.
+The PWA receives initial statuses from `task.list` on load. It subscribes to `host-event.<activeHostId>.>` for live updates; on each notification it parses the `event_type` field and calls the host's `task.status` RPC to fetch the current status. Task cards display the `user_prompt` as the title (truncated to 2 lines) and a status indicator: a marching dots animation when running (`started`), a red dot for errors (`aborted` or `failed`), a gray dot when the schedule is disabled or absent, and a green dot when idle (no entry or `finished`). When the last run was successful (`finished`), a "View Result" button loads the task's result file in a popup dialog. The `specific_times` date/time picker only allows selecting future dates and times.
 
 The Web Server subscribes to `host-event.>` and sends push notifications based on `event_type`: confirmation pushes for `confirm-request`, dismiss pushes for `confirm-resolved`, permission pushes for `permission-request`, dismiss pushes for `permission-resolved`, and report-ready/failure pushes for `report-generated` events.
 
@@ -276,40 +276,40 @@ The PWA connects to **one host at a time**. A host menu (hamburger drawer) lets
 
 2. If hosts are paired, PWA fetches host-scoped NATS credentials from `GET /api/nats-credentials/<hostId>` (returns `{ natsWsUrl, natsJwt, natsNkeySeed }`) and connects to NATS via WebSocket using JWT auth. The credentials are scoped to the paired host's subjects only.
 
-3. PWA sends a `task.list` request to `host.<host_id>.rpc.task.list` using NATS request-reply, including the `clientToken` in the payload. The PWA uses the response for bootstrap metadata (agents, host platform, version, capability tokens) that both the Sessions tab's composer and the Tasks tab depend on.
+3. PWA sends a `host.info` request using NATS request-reply, including the `clientToken` in the payload. The response carries bootstrap metadata (`agents`, `host_platform`, `version`, `capability_tokens`) and `pending_prompts` — any prompts already open on the host when the PWA connected. The Dashboard consumes this once per connection; both tabs read from it.
 
-4. PWA lands on the Sessions tab and fetches run history via `taskrun.list`. If the host responds to `task.list`, it returns `{ tasks: [...] }` — an array of **flat task objects** (frontmatter fields spread to the top level) used by the Tasks tab. If the request fails with NATS 503 ("no responders"), the PWA shows an empty state — this is not treated as an error.
+4. PWA lands on the Sessions tab and fetches run history via `taskrun.list`. `task.list` is not called at startup — it fires lazily the first time the user opens the Tasks tab. If either RPC fails with NATS 503 ("no responders"), the PWA shows an empty state — this is not treated as an error.
 
 5. PWA registers the service worker and subscribes the browser for Web Push notifications (via `pushManager.subscribe` with the server's VAPID public key). The push subscription is sent to `POST /api/push/subscribe` with the `hostId` so the server can relay notifications to the device.
 
-6. PWA discovers pending confirmations from the `task.list` RPC response — tasks with a pending confirmation, permission, or input request are shown as interactive modals. The PWA responds by calling the `task.user_input` RPC on the host, which resolves the in-memory pending request held by the serve daemon. The `run` process (blocked on an HTTP call to the serve daemon) receives the response and proceeds or exits accordingly.
+6. Initial pending-prompt discovery uses `host.info.pending_prompts`: each entry is `{ key, type, params?, meta? }` where `meta` carries the display context (`session_id`, `session_name`, `description`, `input_questions`) needed to render the modal cold. The PWA seeds its modal state maps from this array. After connection, live arrivals come through the NATS event subscription. The PWA responds by calling the `task.user_input` RPC on the host, which resolves the in-memory pending request held by the serve daemon. The `run` process (blocked on an HTTP call to the serve daemon) receives the response and proceeds or exits accordingly.
 
 ### 4.2 UI Layout: Sessions & Tasks Tabs
 
 The PWA has two tabs: **Sessions** (default, at `/`) and **Tasks** (secondary, at `/tasks`). Sessions is the primary workflow — it lists all run history across tasks (a "session" is a single run) and includes a session composer at the top of the list.
 
 * **Session composer:** An inline textarea with an agent picker, a yolo-mode toggle, and a round play button. Entering text and clicking play dispatches `task.run_oneoff`, starting an immediate unsaved session. The composer never opens a dialog; typing is direct. When the textarea has content, navigating away (tab switch, host switch, browser reload, clicking a session row) triggers a confirmation dialog so the draft isn't lost silently.
-* **Tasks tab:** Lists saved tasks (scheduled or reusable). The "Describe your new task..." card opens the full task form, which is used only to create/edit saved or scheduled tasks — it has no Run button (run one-offs via the session composer instead). The form's primary action is "Save" (no schedule) or "Schedule" (when triggers are configured).
+* **Tasks tab:** Lists saved tasks (scheduled or reusable). A floating round `+` button in the bottom-right of the screen opens the task form, which is used only to create/edit saved or scheduled tasks — it has no Run button (run one-offs via the session composer instead). The form's primary action is "Save" (no schedule) or "Schedule" (when a schedule is configured).
 
 Bootstrap data (agents, host version, host platform, capability tokens) is fetched once per connection at the Dashboard level via `host.info` — independent of which tab is active. `task.list` is called lazily on the Tasks tab mount; `taskrun.list` is called lazily on the Sessions tab mount. Neither list RPC carries bootstrap metadata.
 
-Dashboard owns the always-on NATS event subscription and renders pending `confirm-request` / `permission-request` / `input-request` modals via React portal, so prompts surface regardless of which tab is active. Initial pending prompts (those already open when the PWA connects) are seeded from `host.info`'s `pending_prompts` field — each entry carries the display context (`description`, `agent_name`, `task_name`) needed to render the modal cold, since the task list is no longer available at bootstrap.
+Dashboard owns the always-on NATS event subscription and renders pending `confirm-request` / `permission-request` / `input-request` modals via React portal, so prompts surface regardless of which tab is active. Initial pending prompts (those already open when the PWA connects) are seeded from `host.info`'s `pending_prompts` field — each entry carries the display context (`session_name`, `description`, `input_questions`) needed to render the modal cold, since the task list is no longer available at bootstrap. `session_name` is a unified label: agent name for confirm/input, task name for permission.
 
 ### 4.3 Task Creation & Update
 
-1. User clicks the "Describe your new task..." placeholder in the Tasks tab, which opens the task form directly.
+1. User taps the floating `+` button on the Tasks tab, which opens the task form.
 
-2. User enters a prompt, selects an agent, configures triggers (UI translates human-readable times to cron formats) and confirmation settings, and clicks "Save" (no schedule) or "Schedule" (with triggers).
+2. User enters a prompt, selects an agent, configures the schedule (UI translates human-readable times to cron expressions or ISO datetime strings) and confirmation settings, and clicks "Save" (no schedule) or "Schedule" (with a schedule).
 
 3. PWA sends `task.create` (or `task.update`) via NATS request-reply to Host (45s timeout). For prompts > 50 chars, the host generates a concise task name by running the configured agent CLI in non-interactive mode (e.g., `claude -p "Generate a concise 3-6 word name for this task..."`). For shorter prompts, the prompt is used directly as the name.
 
 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. The `triggers` field defaults to `[]` if omitted or undefined.
+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.
 
 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.
 
-7. **OS Integration:** Host translates triggers into a systemd user timer (`~/.config/systemd/user/palmier-task-<task-id>.timer` and `.service`). The `.service` runs `palmier run <task-id>`, which executes the task as a background process. Host runs `systemctl --user daemon-reload` and enables the timer.
+7. **OS Integration:** Host translates the schedule into a systemd user timer (`~/.config/systemd/user/palmier-task-<task-id>.timer` and `.service`). The `.service` runs `palmier run <task-id>`, which executes the task as a background process. Host runs `systemctl --user daemon-reload` and enables the timer.
 
 ### 4.4 On-Demand Execution
 
@@ -379,7 +379,7 @@ When a task has a `command` field set, `palmier run` enters command-triggered mo
 
 5. **On command exit or signal**: each agent invocation is written as a conversation entry in the RESULT file. Per-line agent outputs are also logged to `command-output.log` in the task directory.
 
-6. **Composable with triggers**: cron/once triggers start `palmier run` on schedule, which spawns the command. The command runs until it exits or the task is aborted.
+6. **Composable with schedules**: the configured schedule starts `palmier run` at the scheduled time, which spawns the command. The command runs until it exits or the task is aborted.
 
 ### 5.4 Failsafes & Constraints
 

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