palmier 0.7.7 → 0.7.8

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

@@ -1,4 +1,5 @@
 import { useState, useEffect } from "react";
+import { createPortal } from "react-dom";
 import { useNavigate, useLocation, useParams } from "react-router-dom";
 
 import { useHostStore } from "../contexts/HostStoreContext";
@@ -10,6 +11,37 @@ import RunsView from "../components/RunsView";
 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,7 +51,7 @@ 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
@@ -48,16 +80,205 @@ export default function Dashboard() {
   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 TaskListView 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 +299,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 +336,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 +352,17 @@ export default function Dashboard() {
           </div>
         ) : showTaskContent ? (
           <>
-            <div style={{ display: !isRunsTab ? "contents" : "none" }}>
+            {isTasksTab && !isRunDetail && (
               <TaskListView
                 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}
@@ -153,14 +372,15 @@ export default function Dashboard() {
                 taskId={params.taskId!}
                 runId={decodeURIComponent(effectiveRunId!)}
               />
-            ) : isRunsTab ? (
+            ) : !isTasksTab ? (
               <RunsView
                 connected={connected}
                 hostId={activeHostId}
                 request={request}
                 subscribeEvents={subscribeEvents}
+                agents={agents}
                 filterTaskId={runsFilterTaskId}
-                onClearFilter={() => navigate("/runs")}
+                onClearFilter={() => { if (confirmLeaveDraft()) navigate("/"); }}
               />
             ) : null}
           </>
@@ -221,6 +441,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

@@ -2,6 +2,7 @@ export interface AgentInfo {
   key: string;
   label: string;
   supportsPermissions?: boolean;
+  supportsYolo?: boolean;
 }
 
 
@@ -41,12 +42,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,7 +116,8 @@ 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. |
@@ -275,19 +276,30 @@ 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 `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.
 
-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`. 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.
 
 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.
 
-### 4.2 Task Creation & Update
+### 4.2 UI Layout: Sessions & Tasks Tabs
 
-1. User clicks the "Describe your new task..." placeholder in the task list view, which opens the task form directly.
+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.
 
-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).
+* **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).
+
+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.
+
+### 4.3 Task Creation & Update
+
+1. User clicks the "Describe your new task..." placeholder in the Tasks tab, which opens the task form directly.
+
+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).
 
 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.
 
@@ -299,16 +311,17 @@ The PWA connects to **one host at a time**. A host menu (hamburger drawer) lets
 
 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.
 
-### 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.
 

package/src/agents/agent.ts

@@ -44,6 +44,9 @@ export interface AgentTool {
    *  If false, the permissions section is omitted from agent instructions. */
   supportsPermissions: boolean;
 
+  /** Whether this agent supports yolo mode (auto-approve all tools). */
+  supportsYolo: boolean;
+
   /** Detect whether the agent CLI is available and perform any agent-specific
    *  initialization. Returns true if the agent was detected and initialized successfully. */
   init(): Promise<boolean>;
@@ -93,6 +96,7 @@ export interface DetectedAgent {
   key: string;
   label: string;
   supportsPermissions: boolean;
+  supportsYolo: boolean;
 }
 
 export async function detectAgents(): Promise<DetectedAgent[]> {
@@ -100,7 +104,7 @@ export async function detectAgents(): Promise<DetectedAgent[]> {
   for (const [key, agent] of Object.entries(agentRegistry)) {
     const label = agentLabels[key] ?? key;
     const ok = await agent.init();
-    if (ok) detected.push({ key, label, supportsPermissions: agent.supportsPermissions });
+    if (ok) detected.push({ key, label, supportsPermissions: agent.supportsPermissions, supportsYolo: agent.supportsYolo });
   }
   return detected;
 }

package/src/agents/aider.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class Aider implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "aider", args: ["--message", prompt] };
   }

package/src/agents/claude.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class ClaudeAgent implements AgentTool {
   supportsPermissions = true;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "claude", args: ["-p", prompt] };
   }

package/src/agents/cline.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class Cline implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "cline ", args: ["--yolo", "-p", prompt] };
   }

package/src/agents/codex.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class CodexAgent implements AgentTool {
   supportsPermissions = true;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "codex", args: ["exec", "--skip-git-repo-check", prompt] };
   }

package/src/agents/copilot.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class CopilotAgent implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "copilot", args: ["-p", prompt] };
   }

package/src/agents/cursor.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class Cursor implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "cursor", args: ["-p", prompt] };
   }

package/src/agents/deepagents.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class DeepAgents implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "deepagents", args: ["--non-interactive", prompt] };
   }

package/src/agents/droid.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class DroidAgent implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "droid", args: ["exec", prompt] };
   }

package/src/agents/gemini.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class GeminiAgent implements AgentTool {
   supportsPermissions = true;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "gemini", args: ["--prompt", prompt] };
   }

package/src/agents/goose.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class GooseAgent implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "goose", args: ["run", "--text", prompt] };
   }

package/src/agents/hermes.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class Hermes implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "hermes", args: ["chat", "-q", prompt] };
   }

package/src/agents/kimi.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class KimiAgent implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "kimi", args: ["-p", prompt] };
   }

package/src/agents/kiro.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class Kiro implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "kiro-cli", args: ["--no-interactive", prompt] };
   }