palmier 0.7.8 → 0.7.9

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/mcp-tools.ts

@@ -1,8 +1,8 @@
 import { StringCodec, type NatsConnection } from "nats";
 import { registerPending } from "./pending-requests.js";
 import { getCapabilityDevice } from "./device-capabilities.js";
-import { getNotifications } from "./notification-store.js";
-import { getSmsMessages } from "./sms-store.js";
+import { getNotifications, onNotificationsChanged } from "./notification-store.js";
+import { getSmsMessages, onSmsChanged } from "./sms-store.js";
 import type { HostConfig } from "./types.js";
 
 export class ToolError extends Error {
@@ -750,6 +750,8 @@ export interface ResourceDefinition {
   restPath: string;
   /** Return the current resource content. */
   read: () => unknown;
+  /** Register a listener for content changes. Returns an unsubscribe function. */
+  subscribe: (listener: () => void) => () => void;
 }
 
 const deviceNotificationsResource: ResourceDefinition = {
@@ -762,6 +764,7 @@ const deviceNotificationsResource: ResourceDefinition = {
   mimeType: "application/json",
   restPath: "/notifications",
   read: getNotifications,
+  subscribe: onNotificationsChanged,
 };
 
 const deviceSmsResource: ResourceDefinition = {
@@ -774,6 +777,7 @@ const deviceSmsResource: ResourceDefinition = {
   mimeType: "application/json",
   restPath: "/sms-messages",
   read: getSmsMessages,
+  subscribe: onSmsChanged,
 };
 
 export const agentResources: ResourceDefinition[] = [deviceNotificationsResource, deviceSmsResource];

package/src/platform/linux.ts

@@ -196,15 +196,17 @@ Environment=PATH=${process.env.PATH || "/usr/local/bin:/usr/bin:/bin"}
     fs.writeFileSync(path.join(UNIT_DIR, serviceName), serviceContent, "utf-8");
     daemonReload();
 
-    // Only create and enable a timer if triggers exist and are enabled
-    if (!task.frontmatter.triggers_enabled) return;
-    const triggers = task.frontmatter.triggers || [];
+    // Only create and enable a timer if the schedule exists and is enabled
+    if (!task.frontmatter.schedule_enabled) return;
+    const scheduleType = task.frontmatter.schedule_type;
+    const scheduleValues = task.frontmatter.schedule_values;
+    if (!scheduleType || !scheduleValues?.length) return;
     const onCalendarLines: string[] = [];
-    for (const trigger of triggers) {
-      if (trigger.type === "cron") {
-        onCalendarLines.push(`OnCalendar=${cronToOnCalendar(trigger.value)}`);
-      } else if (trigger.type === "once") {
-        onCalendarLines.push(`OnActiveSec=${trigger.value}`);
+    for (const value of scheduleValues) {
+      if (scheduleType === "crons") {
+        onCalendarLines.push(`OnCalendar=${cronToOnCalendar(value)}`);
+      } else if (scheduleType === "specific_times") {
+        onCalendarLines.push(`OnActiveSec=${value}`);
       }
     }
 

package/src/platform/windows.ts

@@ -14,22 +14,23 @@ const DAEMON_TASK_NAME = "PalmierDaemon";
 const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
 
 /**
- * Convert a cron expression or "once" trigger to Task Scheduler XML trigger elements.
+ * Convert a single schedule value to a Task Scheduler XML trigger element.
  *
- * Only these cron patterns (produced by the PWA UI) are handled:
+ * `specific_times` values are ISO datetime strings like "2026-03-28T09:00".
+ *
+ * `crons` values are cron expressions. Only these patterns (produced by the PWA UI) are handled:
  *   hourly:  "0 * * * *"
  *   daily:   "MM HH * * *"
  *   weekly:  "MM HH * * D"
  *   monthly: "MM HH D * *"
  */
-export function triggerToXml(trigger: { type: string; value: string }): string {
-  if (trigger.type === "once") {
-    // ISO datetime "2026-03-28T09:00"
-    return `<TimeTrigger><StartBoundary>${trigger.value}:00</StartBoundary></TimeTrigger>`;
+export function scheduleValueToXml(scheduleType: "crons" | "specific_times", value: string): string {
+  if (scheduleType === "specific_times") {
+    return `<TimeTrigger><StartBoundary>${value}:00</StartBoundary></TimeTrigger>`;
   }
 
-  const parts = trigger.value.trim().split(/\s+/);
-  if (parts.length !== 5) throw new Error(`Invalid cron expression: ${trigger.value}`);
+  const parts = value.trim().split(/\s+/);
+  if (parts.length !== 5) throw new Error(`Invalid cron expression: ${value}`);
   const [minute, hour, dayOfMonth, , dayOfWeek] = parts;
   const st = `${hour.padStart(2, "0")}:${minute.padStart(2, "0")}:00`;
   // StartBoundary needs a full date; use a past date as the anchor
@@ -193,12 +194,14 @@ export class WindowsPlatform implements PlatformService {
 
     // Build trigger XML elements
     const triggerElements: string[] = [];
-    if (task.frontmatter.triggers_enabled) {
-      for (const trigger of task.frontmatter.triggers ?? []) {
+    const scheduleType = task.frontmatter.schedule_type;
+    const scheduleValues = task.frontmatter.schedule_values;
+    if (task.frontmatter.schedule_enabled && scheduleType && scheduleValues?.length) {
+      for (const value of scheduleValues) {
         try {
-          triggerElements.push(triggerToXml(trigger));
+          triggerElements.push(scheduleValueToXml(scheduleType, value));
         } catch (err) {
-          console.error(`Invalid trigger: ${err}`);
+          console.error(`Invalid schedule value: ${err}`);
         }
       }
     }

package/src/rpc-handler.ts

@@ -194,8 +194,9 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const params = request.params as {
           user_prompt: string;
           agent: string;
-          triggers?: Array<{ type: "cron" | "once"; value: string }>;
-          triggers_enabled?: boolean;
+          schedule_type?: "crons" | "specific_times";
+          schedule_values?: string[];
+          schedule_enabled?: boolean;
           requires_confirmation?: boolean;
           yolo_mode?: boolean;
           foreground_mode?: boolean;
@@ -214,9 +215,11 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
             name,
             user_prompt: params.user_prompt,
             agent: params.agent,
-            triggers: params.triggers ?? [],
-            triggers_enabled: params.triggers_enabled ?? true,
+            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.yolo_mode ? { yolo_mode: true } : {}),
             ...(params.foreground_mode ? { foreground_mode: true } : {}),
             ...(params.command ? { command: params.command } : {}),
@@ -235,8 +238,9 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           id: string;
           user_prompt?: string;
           agent?: string;
-          triggers?: Array<{ type: "cron" | "once"; value: string }>;
-          triggers_enabled?: boolean;
+          schedule_type?: "crons" | "specific_times" | null;
+          schedule_values?: string[] | null;
+          schedule_enabled?: boolean;
           requires_confirmation?: boolean;
           yolo_mode?: boolean;
           foreground_mode?: boolean;
@@ -253,8 +257,21 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         // Merge updates
         if (params.user_prompt !== undefined) existing.frontmatter.user_prompt = params.user_prompt;
         if (params.agent !== undefined) existing.frontmatter.agent = params.agent;
-        if (params.triggers !== undefined) existing.frontmatter.triggers = params.triggers;
-        if (params.triggers_enabled !== undefined) existing.frontmatter.triggers_enabled = params.triggers_enabled;
+        if (params.schedule_type !== undefined) {
+          if (params.schedule_type) {
+            existing.frontmatter.schedule_type = params.schedule_type;
+          } else {
+            delete existing.frontmatter.schedule_type;
+          }
+        }
+        if (params.schedule_values !== undefined) {
+          if (params.schedule_values && params.schedule_values.length > 0) {
+            existing.frontmatter.schedule_values = params.schedule_values;
+          } else {
+            delete existing.frontmatter.schedule_values;
+          }
+        }
+        if (params.schedule_enabled !== undefined) existing.frontmatter.schedule_enabled = params.schedule_enabled;
         if (params.requires_confirmation !== undefined)
           existing.frontmatter.requires_confirmation = params.requires_confirmation;
         if (params.yolo_mode !== undefined) {
@@ -314,8 +331,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
             name,
             user_prompt: params.user_prompt,
             agent: params.agent,
-            triggers: [],
-            triggers_enabled: false,
+            schedule_enabled: false,
             requires_confirmation: params.requires_confirmation ?? false,
             ...(params.yolo_mode ? { yolo_mode: true } : {}),
             ...(params.foreground_mode ? { foreground_mode: true } : {}),