palmier 0.7.7 → 0.7.9

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

@@ -1,15 +1,47 @@
 import { useState, useEffect } from "react";
+import { createPortal } from "react-dom";
 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";
+import { setAgentLabels } from "../agentLabels";
+import { confirmLeaveDraft } from "../draftGuard";
+import { MIN_HOST_VERSION } from "../constants";
+import type { AgentInfo, RequiredPermission } from "../types";
+
+function isOlderThan(current: string, minimum: string): boolean {
+  if (current.includes("-")) return false;
+  const a = current.split(".").map(Number);
+  const b = minimum.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return true;
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return false;
+  }
+  return false;
+}
+
+interface PendingPrompt {
+  key: string;
+  type: "confirmation" | "permission" | "input";
+  params?: RequiredPermission[] | string[];
+  meta?: {
+    session_id?: string;
+    session_name?: string;
+    description?: string;
+    input_questions?: string[];
+  };
+}
+
+interface ConfirmPrompt { description: string; sessionName?: string }
+interface PermissionPrompt { permissions: RequiredPermission[]; sessionName?: string }
+interface InputPrompt { questions: string[]; description?: string; sessionName?: string }
 
 export default function Dashboard() {
   const { pairedHosts, activeHostId, removePairedHost } = useHostStore();
@@ -19,45 +51,217 @@ export default function Dashboard() {
   const params = useParams<{ taskId?: string; runId?: string }>();
   const isDesktop = useMediaQuery("(min-width: 768px)");
 
-  const isRunsTab = location.pathname.startsWith("/runs");
+  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);
   const [updateError, setUpdateError] = useState<string | null>(null);
   const [daemonVersion, setDaemonVersion] = useState<string | null>(null);
   const [capabilityTokens, setCapabilityTokens] = useState<Record<string, string | null>>({});
+  const [agents, setAgents] = useState<AgentInfo[]>([]);
+  const [hostPlatform, setHostPlatform] = useState<string | undefined>();
+
+  // Pending prompt state — owned by Dashboard because these modals must show
+  // regardless of which tab (Sessions/Tasks/RunDetail) is currently rendered.
+  const [pendingConfirms, setPendingConfirms] = useState<Map<string, ConfirmPrompt>>(new Map());
+  const [pendingPermissions, setPendingPermissions] = useState<Map<string, PermissionPrompt>>(new Map());
+  const [pendingInputs, setPendingInputs] = useState<Map<string, InputPrompt>>(new Map());
+  const [inputValues, setInputValues] = useState<Map<string, string[]>>(new Map());
 
-  // Register push subscription for the active host
   usePushSubscription();
 
-  // Reset scroll when switching hosts
   useEffect(() => {
     window.scrollTo(0, 0);
   }, [activeHostId]);
 
+  // host.info bootstrap: agents/version/platform + any prompts that were already
+  // pending when this PWA connected. Runs once per (host, connection).
+  useEffect(() => {
+    if (!connected) return;
+    request<{
+      agents?: AgentInfo[];
+      version?: string | null;
+      host_platform?: string;
+      capability_tokens?: Record<string, string | null>;
+      pending_prompts?: PendingPrompt[];
+    }>("host.info")
+      .then((result) => {
+        setAgents(result.agents ?? []);
+        setHostPlatform(result.host_platform);
+        setCapabilityTokens(result.capability_tokens ?? {});
+        setAgentLabels(result.agents ?? []);
+        const version = result.version ?? null;
+        setDaemonVersion(version);
+        setUpdateRequired(!!version && isOlderThan(version, MIN_HOST_VERSION));
+
+        // Seed modal state from already-pending prompts.
+        const confirms = new Map<string, ConfirmPrompt>();
+        const perms = new Map<string, PermissionPrompt>();
+        const inputs = new Map<string, InputPrompt>();
+        const inputVals = new Map<string, string[]>();
+        for (const p of result.pending_prompts ?? []) {
+          if (p.type === "confirmation") {
+            confirms.set(p.key, {
+              description: p.meta?.description ?? "",
+              sessionName: p.meta?.session_name,
+            });
+          } else if (p.type === "permission") {
+            perms.set(p.key, {
+              permissions: (p.params as RequiredPermission[]) ?? [],
+              sessionName: p.meta?.session_name,
+            });
+          } else if (p.type === "input") {
+            const questions = (p.params as string[]) ?? p.meta?.input_questions ?? [];
+            inputs.set(p.key, {
+              questions,
+              description: p.meta?.description,
+              sessionName: p.meta?.session_name,
+            });
+            inputVals.set(p.key, new Array(questions.length).fill(""));
+          }
+        }
+        setPendingConfirms(confirms);
+        setPendingPermissions(perms);
+        setPendingInputs(inputs);
+        setInputValues(inputVals);
+      })
+      .catch(() => { /* silent — update-required prompt guards the broken case */ });
+  }, [connected, activeHostId, request]);
+
+  // Always-on event subscription for modal lifecycle. Independent of which tab
+  // is active. Task-card status updates happen inside TasksView while mounted.
+  useEffect(() => {
+    if (!connected || !activeHostId) return;
+    const unsubscribe = subscribeEvents(activeHostId, (msg) => {
+      const tokens = msg.subject.split(".");
+      if (tokens.length < 3) return;
+      const taskId = tokens.slice(2).join(".");
+
+      let parsed: Record<string, unknown> = {};
+      try {
+        parsed = JSON.parse(new TextDecoder().decode(msg.data)) as Record<string, unknown>;
+      } catch { return; }
+      const eventType = parsed.event_type as string | undefined;
+      const sessionId = parsed.session_id as string | undefined;
+
+      if (eventType === "input-request" && sessionId) {
+        const questions = parsed.input_questions as string[] | undefined;
+        const sessionName = parsed.session_name as string | undefined;
+        const description = parsed.description as string | undefined;
+        if (questions?.length) {
+          setPendingInputs((prev) => {
+            if (prev.has(sessionId)) return prev;
+            const next = new Map(prev);
+            next.set(sessionId, { questions, description, sessionName });
+            return next;
+          });
+          setInputValues((prev) => {
+            if (prev.has(sessionId)) return prev;
+            const next = new Map(prev);
+            next.set(sessionId, new Array(questions.length).fill(""));
+            return next;
+          });
+        }
+        return;
+      }
+
+      if (eventType === "input-resolved" && sessionId) {
+        setPendingInputs((prev) => {
+          if (!prev.has(sessionId)) return prev;
+          const next = new Map(prev);
+          next.delete(sessionId);
+          return next;
+        });
+        setInputValues((prev) => {
+          const next = new Map(prev);
+          next.delete(sessionId);
+          return next;
+        });
+        return;
+      }
+
+      if (eventType === "confirm-request" && sessionId) {
+        const description = parsed.description as string | undefined;
+        const sessionName = parsed.session_name as string | undefined;
+        if (description) {
+          setPendingConfirms((prev) => {
+            if (prev.has(sessionId)) return prev;
+            const next = new Map(prev);
+            next.set(sessionId, { description, sessionName });
+            return next;
+          });
+        }
+        return;
+      }
+
+      if (eventType === "confirm-resolved" && sessionId) {
+        setPendingConfirms((prev) => {
+          if (!prev.has(sessionId)) return prev;
+          const next = new Map(prev);
+          next.delete(sessionId);
+          return next;
+        });
+        return;
+      }
+
+      if (eventType === "permission-request") {
+        const permissions = parsed.required_permissions as RequiredPermission[] | undefined;
+        const sessionName = parsed.session_name as string | undefined;
+        if (permissions?.length) {
+          setPendingPermissions((prev) => {
+            if (prev.has(taskId)) return prev;
+            const next = new Map(prev);
+            next.set(taskId, { permissions, sessionName });
+            return next;
+          });
+        }
+        return;
+      }
+
+      if (eventType === "permission-resolved") {
+        setPendingPermissions((prev) => {
+          if (!prev.has(taskId)) return prev;
+          const next = new Map(prev);
+          next.delete(taskId);
+          return next;
+        });
+        return;
+      }
+    });
+    return unsubscribe;
+  }, [connected, activeHostId, subscribeEvents]);
+
+  async function respondToConfirm(sessionId: string, response: "confirmed" | "aborted") {
+    try {
+      await request("task.user_input", { id: sessionId, value: [response] });
+    } catch (err) {
+      console.error("[Dashboard] Failed to respond to confirmation:", err);
+    }
+  }
+
+  async function respondToPermission(taskId: string, response: "granted" | "granted_all" | "aborted") {
+    try {
+      await request("task.user_input", { id: taskId, value: [response] });
+    } catch (err) {
+      console.error("[Dashboard] Failed to respond to permission request:", err);
+    }
+  }
+
+  async function respondToInput(sessionId: string, values: string[]) {
+    try {
+      await request("task.user_input", { id: sessionId, value: values });
+    } catch (err) {
+      console.error("[Dashboard] Failed to respond to input request:", err);
+    }
+  }
+
   function handleViewRun(taskId: string, runId?: string) {
+    if (!confirmLeaveDraft()) return;
     if (runId) {
       navigate(`/runs/${encodeURIComponent(taskId)}/${encodeURIComponent(runId)}`);
     } else {
@@ -78,7 +282,6 @@ export default function Dashboard() {
     } catch {
       // Expected: connection drops during daemon restart
     }
-    // Daemon will restart; reload after it has time to come back up.
     setTimeout(() => window.location.reload(), 10000);
   }
 
@@ -116,7 +319,7 @@ export default function Dashboard() {
             <div className="revoked-actions">
               <button
                 className="btn btn-primary"
-                onClick={() => navigate("/pair")}
+                onClick={() => { if (confirmLeaveDraft()) navigate("/pair"); }}
               >
                 Re-pair Device
               </button>
@@ -132,18 +335,17 @@ export default function Dashboard() {
           </div>
         ) : showTaskContent ? (
           <>
-            <div style={{ display: !isRunsTab ? "contents" : "none" }}>
-              <TaskListView
+            {isTasksTab && !isRunDetail && (
+              <TasksView
                 connected={connected}
                 hostId={activeHostId}
                 request={request}
                 subscribeEvents={subscribeEvents}
+                agents={agents}
+                hostPlatform={hostPlatform}
                 onViewRun={handleViewRun}
-                onUpdateRequired={setUpdateRequired}
-                onVersion={setDaemonVersion}
-                onCapabilityTokens={setCapabilityTokens}
               />
-            </div>
+            )}
             {isRunDetail ? (
               <RunDetailView
                 connected={connected}
@@ -151,16 +353,17 @@ export default function Dashboard() {
                 request={request}
                 subscribeEvents={subscribeEvents}
                 taskId={params.taskId!}
-                runId={decodeURIComponent(effectiveRunId!)}
+                runId={decodeURIComponent(params.runId!)}
               />
-            ) : isRunsTab ? (
-              <RunsView
+            ) : !isTasksTab ? (
+              <SessionsView
                 connected={connected}
                 hostId={activeHostId}
                 request={request}
                 subscribeEvents={subscribeEvents}
+                agents={agents}
                 filterTaskId={runsFilterTaskId}
-                onClearFilter={() => navigate("/runs")}
+                onClearFilter={() => { if (confirmLeaveDraft()) navigate("/"); }}
               />
             ) : null}
           </>
@@ -221,6 +424,109 @@ export default function Dashboard() {
       )}
 
       </div>
+
+      {createPortal(<>
+        {[...pendingConfirms.entries()].map(([sessionId, { description, sessionName }]) => (
+          <div key={sessionId} className="confirm-modal-overlay">
+            <div className="confirm-modal">
+              <h2 className="confirm-modal-title">Confirmation Required</h2>
+              {sessionName && <p className="confirm-modal-subtitle">{sessionName}</p>}
+              <p className="confirm-modal-message">{description}</p>
+              <div className="confirm-modal-actions">
+                <button className="btn btn-primary" onClick={() => respondToConfirm(sessionId, "confirmed")}>
+                  Confirm
+                </button>
+                <button className="btn btn-secondary" onClick={() => respondToConfirm(sessionId, "aborted")}>
+                  Abort
+                </button>
+              </div>
+            </div>
+          </div>
+        ))}
+
+        {[...pendingPermissions.entries()].map(([taskId, { permissions, sessionName }]) => (
+          <div key={taskId} className="confirm-modal-overlay">
+            <div className="confirm-modal permission-modal">
+              <h2 className="confirm-modal-title">Permission Required</h2>
+              <p className="confirm-modal-message">
+                <strong>{sessionName || taskId}</strong>
+              </p>
+              <div className="permission-list">
+                {permissions.map((p, i) => (
+                  <div key={i} className="permission-item">
+                    <span className="permission-name">{p.name}</span>
+                    {p.description && <span className="permission-desc">{p.description}</span>}
+                  </div>
+                ))}
+              </div>
+              <div className="permission-actions">
+                <button className="btn btn-primary" onClick={() => respondToPermission(taskId, "granted")}>
+                  Allow Once
+                </button>
+                <button className="btn btn-secondary" onClick={() => respondToPermission(taskId, "granted_all")}>
+                  Allow Always
+                </button>
+              </div>
+              <button
+                className="permission-abort-link"
+                onClick={() => respondToPermission(taskId, "aborted")}
+              >
+                Deny & Abort Task
+              </button>
+            </div>
+          </div>
+        ))}
+
+        {[...pendingInputs.entries()].map(([sessionId, { questions, description, sessionName }]) => {
+          const values = inputValues.get(sessionId) ?? new Array(questions.length).fill("");
+          return (
+            <div key={sessionId} className="confirm-modal-overlay">
+              <div className="confirm-modal input-modal">
+                <h2 className="confirm-modal-title">Input Required</h2>
+                {sessionName && <p className="confirm-modal-subtitle">{sessionName}</p>}
+                {description && <p className="confirm-modal-message">{description}</p>}
+                <div className="input-list">
+                  {questions.map((desc: string, i: number) => (
+                    <div key={i} className="input-item">
+                      <label className="input-label">{desc}</label>
+                      <input
+                        type="text"
+                        className="input-field"
+                        value={values[i] ?? ""}
+                        onChange={(e) => {
+                          setInputValues((prev) => {
+                            const next = new Map(prev);
+                            const arr = [...(next.get(sessionId) ?? [])];
+                            arr[i] = e.target.value;
+                            next.set(sessionId, arr);
+                            return next;
+                          });
+                        }}
+                        autoFocus={i === 0}
+                      />
+                    </div>
+                  ))}
+                </div>
+                <div className="input-actions">
+                  <button
+                    className="btn btn-primary"
+                    disabled={values.some((v) => !v.trim())}
+                    onClick={() => respondToInput(sessionId, values)}
+                  >
+                    Submit
+                  </button>
+                </div>
+                <button
+                  className="permission-abort-link"
+                  onClick={() => respondToInput(sessionId, ["aborted"])}
+                >
+                  Cancel
+                </button>
+              </div>
+            </div>
+          );
+        })}
+      </>, document.body)}
     </div>
   );
 }

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

@@ -1,7 +1,8 @@
 export interface AgentInfo {
   key: string;
   label: string;
-  supportsPermissions?: boolean;
+  supportsPermissions: boolean;
+  supportsYolo: boolean;
 }
 
 
@@ -10,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;
@@ -19,11 +21,6 @@ export interface Task {
   command?: string;
 }
 
-export interface Trigger {
-  type: "cron" | "once";
-  value: string;
-}
-
 export interface RequiredPermission {
   name: string;
   description: string;
@@ -41,12 +38,6 @@ export interface TaskStatus {
   running_state: TaskRunningState;
   /** UTC time in milliseconds since epoch */
   time_stamp: number;
-  /** Whether this task is awaiting user confirmation */
-  pending_confirmation?: boolean;
-  /** Permissions the task needs granted to continue */
-  pending_permission?: RequiredPermission[];
-  pending_input?: string[];
-  user_input?: string[];
 }
 
 export interface HistoryEntry {

package/palmier-server/spec.md

@@ -116,10 +116,11 @@ The **RPC method is derived from the NATS subject**, not the message body. The h
 
 | Method | Params | Description |
 |---|---|---|
-| `task.list` | *(none)* | List all tasks with frontmatter, created_at, and current status. Returns `agents` array of detected CLIs, `host_platform`, and `version`. |
+| `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`) |
@@ -214,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
 
@@ -249,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.
 
@@ -275,40 +276,52 @@ 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.
+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. If the host responds, it returns `{ tasks: [...] }` — an array of **flat task objects** (frontmatter fields spread to the top level) and displays the task list. If the request fails with NATS 503 ("no responders"), the PWA shows an empty task list — 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). 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 (`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.2 Task Creation & Update
+### 4.3 Task Creation & Update
 
-1. User clicks the "Describe your new task..." placeholder in the task list view, 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 "Create" (or "Update" for existing tasks).
+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.3 On-Demand Execution
+### 4.4 On-Demand Execution
 
 Any task that is not currently running can be executed immediately:
 
-* **PWA:** A "Run Now" button is shown on each task card when the task is not already running. Clicking it sends a `task.run` request via NATS request-reply to the Host, which starts execution via the system scheduler (`systemctl --user start` on Linux, `schtasks /run` on Windows).
+* **PWA (saved task):** A "Run Now" button is shown on each task card when the task is not already running. Clicking it sends a `task.run` request via NATS request-reply to the Host, which starts execution via the system scheduler (`systemctl --user start` on Linux, `schtasks /run` on Windows).
+* **PWA (one-off session):** The session composer on the Sessions tab sends `task.run_oneoff` with `{ user_prompt, agent, yolo_mode }`. The host creates an ephemeral task, runs it, and returns `{ task_id, run_id }`; the PWA navigates to the run detail view.
 * **CLI:** `palmier run <task-id>` executes the task directly (outside the system scheduler).
 
 Both paths follow the same execution loop described in §5.2 (including confirmation checks if configured). The system scheduler prevents concurrent runs of the same task — if the service/task is already active, the start command is a no-op.
 
-### 4.4 Task Deletion
+### 4.5 Task Deletion
 
 1. PWA sends `task.delete` via NATS request-reply.
 
@@ -366,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