@saadnvd1/agent-os 0.3.551 → 0.3.553

package/README.md

@@ -26,6 +26,7 @@ and check on all of it from your phone.
 - **Machine load and status.** A load gauge, each session's share of CPU and memory, and Needs you, Working, In review and Done as it changes. [More](docs/guides/sessions.md)
 - **Workspaces.** Group projects, finish work with Done, and get a log of every merged task. [More](docs/reference/workspaces.md)
 - **LumifyHub (optional).** Boards, cards and docs for a workspace, if you want them. [More](docs/lumifyhub.md)
+- **No approvals mode.** One switch in Settings that approves every ask, lets brakes and plan-only tasks through, and starts every agent with its permission prompts off; each approval it makes is logged. Off by default. [More](docs/reference/orchestrator.md#no-approvals-mode)
 - **Also:** a ⌘K palette, code search, a file picker, a git panel, dev servers, up to four panes, and dictation.
 
 ## Documentation

package/app/api/approvals/hook/route.ts

@@ -0,0 +1,34 @@
+import { NextRequest } from "next/server";
+import {
+  noApprovalsOn,
+  recordAutoApproval,
+} from "@/lib/approvals/no-approvals";
+
+// The Claude status hook asks here when a terminal Claude wants a tool
+// permission. While No approvals mode is on the answer is Claude's own
+// "allow" decision; otherwise nothing, and the prompt shows as usual. A
+// question isn't a permission and is never answered. Never fails the hook.
+export async function POST(request: NextRequest) {
+  try {
+    if (!noApprovalsOn()) return new Response("");
+    const input = (await request.json()) as { tool_name?: unknown };
+    const tool = typeof input?.tool_name === "string" ? input.tool_name : "";
+    if (!tool || tool === "AskUserQuestion") return new Response("");
+    recordAutoApproval({
+      source: "terminal",
+      sessionId: request.nextUrl.searchParams.get("session") || null,
+      subject: `${tool} in a terminal session`,
+    });
+    return new Response(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PermissionRequest",
+          decision: { behavior: "allow" },
+        },
+      }),
+      { headers: { "Content-Type": "application/json" } }
+    );
+  } catch {
+    return new Response("");
+  }
+}

package/app/api/approvals/route.ts

@@ -0,0 +1,52 @@
+import { NextRequest, NextResponse } from "next/server";
+import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
+import { switchNoApprovals } from "@/lib/approvals/enable";
+import { listAutoApprovals, noApprovalsOn } from "@/lib/approvals/no-approvals";
+import { NO_APPROVALS_ON_PRESENCE } from "@/lib/orchestrator/presence-binding";
+import { requireApprover } from "@/lib/security/approver";
+import { relyingParty, verifyPresence } from "@/lib/security/presence";
+import { refusalResponse } from "@/lib/security/presence-http";
+import { requireLocalTrust } from "@/lib/security/route-guard";
+
+const view = () => ({ on: noApprovalsOn(), audit: listAutoApprovals(20) });
+
+// GET /api/approvals - whether No approvals mode is on, and its latest audit lines
+export function GET() {
+  return NextResponse.json(view());
+}
+
+// PUT /api/approvals {on, assertion?} - turning it on is deliberate: only
+// this machine or the tailnet, and with Saad's passkey, since it switches
+// off every approval. Turning it off only needs a place that may approve.
+export async function PUT(request: NextRequest) {
+  const body = (await request.json().catch(() => ({}))) as {
+    on?: unknown;
+    assertion?: AuthenticationResponseJSON;
+  };
+  if (typeof body.on !== "boolean")
+    return NextResponse.json(
+      { error: "on must be true or false" },
+      { status: 400 }
+    );
+  if (body.on) {
+    const refused = requireLocalTrust(request);
+    if (refused) return refused;
+    if (!noApprovalsOn()) {
+      try {
+        await verifyPresence(
+          relyingParty(request.headers),
+          body.assertion,
+          "no-approvals-on",
+          NO_APPROVALS_ON_PRESENCE
+        );
+      } catch (error) {
+        return refusalResponse(error);
+      }
+    }
+  } else {
+    const gate = requireApprover(request);
+    if (!gate.ok) return gate.response;
+  }
+  await switchNoApprovals(body.on);
+  return NextResponse.json(view());
+}

package/app/api/devices/network/route.ts

@@ -5,7 +5,7 @@ import { requireLocalTrust } from "@/lib/security/route-guard";
 import { setConnectEnabled } from "@/lib/connect/config";
 import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
 import {
-  mergeApprovalsOn,
+  mergeApprovalsSetting,
   setMergeApprovals,
 } from "@/lib/orchestrator/merge-approvals";
 import { APPROVALS_OFF_PRESENCE } from "@/lib/orchestrator/presence-binding";
@@ -37,7 +37,7 @@ export async function PUT(request: NextRequest) {
   };
   // Switching Saad's merge approvals off lets sensitive PRs merge without
   // him, so it needs his passkey: anything on this machine could ask.
-  if (body.mergeApprovals === false && mergeApprovalsOn()) {
+  if (body.mergeApprovals === false && mergeApprovalsSetting()) {
     try {
       await verifyPresence(
         relyingParty(request.headers),

package/app/api/sessions/[id]/summarize/route.ts

@@ -1,3 +1,4 @@
+import { effectiveAutoApprove } from "@/lib/approvals/no-approvals";
 import { routedRun } from "@/lib/models/launch";
 import { NextRequest, NextResponse } from "next/server";
 import { isRemoteHost } from "@/lib/hosts";
@@ -309,7 +310,7 @@ export async function POST(
       // Start new tmux session with Claude directly
       const isRoot = process.getuid?.() === 0;
       const envPrefix = isRoot ? "IS_SANDBOX=1 " : "";
-      const claudeCmd = session.auto_approve
+      const claudeCmd = effectiveAutoApprove(session.auto_approve)
         ? `${envPrefix}claude --dangerously-skip-permissions`
         : "claude";
 

package/app/page.tsx

@@ -59,6 +59,8 @@ import { useMoveCommands } from "@/components/Tasks/useMoveCommands";
 import dynamic from "next/dynamic";
 import { chatMetaActions } from "@/stores/chatMeta";
 import { useDemoMode } from "@/data/demo";
+import { useQueryClient } from "@tanstack/react-query";
+import { approvalsModeQuery } from "@/data/approvals";
 
 // The app's dialogs open from their stores, so none is needed for the first
 // paint: their code loads right after it.
@@ -159,6 +161,7 @@ function HomeContent() {
   const focusedActiveTab = getActiveTab(focusedPaneId);
   const { isMobile, isHydrated } = useViewport();
   const demo = useDemoMode();
+  const queryClient = useQueryClient();
 
   // Data hooks
   const {
@@ -288,10 +291,16 @@ function HomeContent() {
         clearPendingPrompt(session.id);
       }
 
+      // No approvals mode launches every agent with its permission prompts
+      // off; a failed read launches as the session was set.
+      const noApprovals = await queryClient
+        .fetchQuery(approvalsModeQuery)
+        .then((m) => m.on)
+        .catch(() => false);
       const flags = provider.buildFlags({
         sessionId: session.claude_session_id,
         parentSessionId,
-        autoApprove: session.auto_approve,
+        autoApprove: session.auto_approve || noApprovals,
         model: session.model,
         initialPrompt: initialPrompt || undefined,
       });
@@ -313,7 +322,7 @@ function HomeContent() {
 
       return { sessionName, cwd, command, hostId, sessionId };
     },
-    [sessions, getInitScriptCommand]
+    [sessions, getInitScriptCommand, queryClient]
   );
 
   // Attach a session to a terminal

package/app/pair/page.tsx

@@ -85,8 +85,9 @@ export default function PairPage() {
           <Logo />
           <h1 className="text-xl font-semibold">Pair this device</h1>
           <p className="text-muted-foreground text-sm">
-            On a device that already uses AgentOS, open the menu, choose{" "}
-            <span className="text-foreground">Devices</span>, then{" "}
+            On a device that already uses AgentOS, open{" "}
+            <span className="text-foreground">Settings</span>, choose{" "}
+            <span className="text-foreground">Devices &amp; access</span>, then{" "}
             <span className="text-foreground">Add a device</span>.
           </p>
         </div>

package/components/Approvals/NoApprovalsBadge.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { ShieldOff } from "lucide-react";
+import { useApprovalsModeQuery } from "@/data/approvals";
+import { settingsUiActions } from "@/stores/settingsUi";
+
+// On screen for as long as No approvals mode is on; opens its Settings.
+export function NoApprovalsBadge() {
+  const { data } = useApprovalsModeQuery();
+  if (!data?.on) return null;
+  return (
+    <button
+      type="button"
+      onClick={() => settingsUiActions.open("approvals")}
+      title="No approvals mode is on: nothing waits for a person. Open settings."
+      className="flex h-8 shrink-0 items-center gap-1 rounded-md bg-amber-500/20 px-2 text-xs font-medium text-amber-500 ring-1 ring-amber-500/50"
+    >
+      <ShieldOff className="h-3.5 w-3.5" />
+      No approvals
+    </button>
+  );
+}

package/components/Chat/AccessPicker.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { useApprovalsModeQuery } from "@/data/approvals";
 import {
   Check,
   ChevronDown,
@@ -44,8 +45,19 @@ export function AccessPicker({
   access: ChatAccess;
   onPick: (access: ChatAccess) => void;
 }) {
-  const current = LEVELS[access] ?? LEVELS.full;
+  const noApprovals = !!useApprovalsModeQuery().data?.on;
+  const current = LEVELS[noApprovals ? "full" : access] ?? LEVELS.full;
   const Icon = current.icon;
+  if (noApprovals)
+    return (
+      <span
+        title="No approvals mode is on: every agent runs with full access"
+        className="text-muted-foreground flex h-10 shrink-0 items-center gap-1 px-2 text-xs"
+      >
+        <Icon className="h-3.5 w-3.5" />
+        <span className="hidden sm:inline">{current.label}</span>
+      </span>
+    );
   return (
     <DropdownMenu>
       <DropdownMenuTrigger asChild>

package/components/SessionList/SidebarHeader.tsx

@@ -39,6 +39,7 @@ import { usageUiActions } from "@/stores/usageUi";
 import { WorkspaceSwitcher } from "./WorkspaceSwitcher";
 import { LoadGauge } from "./LoadGauge";
 import { AwayToggle } from "@/components/Away/AwayToggle";
+import { NoApprovalsBadge } from "@/components/Approvals/NoApprovalsBadge";
 import { useSchedulesGlance } from "./useSchedulesGlance";
 import { cn } from "@/lib/utils";
 
@@ -71,6 +72,7 @@ export function SidebarHeader(props: SidebarHeaderProps) {
         <LoadGauge />
       </div>
       <div className="ml-auto flex shrink-0 items-center gap-0.5">
+        <NoApprovalsBadge />
         <AwayToggle />
         <ADropdownMenu
           trigger={

package/components/Settings/NoApprovalsSection.test.ts

@@ -0,0 +1,115 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// Radix dispatches its own events; they must be jsdom's, not Node's.
+for (const key of ["Event", "CustomEvent", "FocusEvent", "HTMLButtonElement"])
+  Object.defineProperty(globalThis, key, {
+    value: (window as unknown as Record<string, unknown>)[key],
+    configurable: true,
+    writable: true,
+  });
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+const state = vi.hoisted(() => ({
+  on: false,
+  audit: [] as object[],
+  mutate: vi.fn(),
+}));
+vi.mock("@/data/approvals", () => ({
+  useApprovalsModeQuery: () => ({
+    isPending: false,
+    isError: false,
+    data: { on: state.on, audit: state.audit },
+  }),
+  useSetApprovalsMode: () => ({
+    mutate: state.mutate,
+    isPending: false,
+    error: null,
+  }),
+}));
+
+const { NoApprovalsSection } = await import("./NoApprovalsSection");
+const { NoApprovalsBadge } =
+  await import("@/components/Approvals/NoApprovalsBadge");
+
+let root: Root;
+let host: HTMLDivElement;
+beforeEach(() => {
+  state.on = false;
+  state.audit = [];
+  state.mutate.mockReset();
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  root = createRoot(host);
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+});
+
+const render = (el: ReturnType<typeof createElement>) =>
+  act(() => root.render(el));
+const click = (el: Element | null) =>
+  act(() => {
+    el?.dispatchEvent(new window.MouseEvent("click", { bubbles: true }));
+  });
+const byText = (text: string) =>
+  [...host.querySelectorAll("button")].find((b) =>
+    b.textContent?.includes(text)
+  ) ?? null;
+
+describe("the No approvals toggle", () => {
+  it("is off, and flipping it warns first without switching anything", () => {
+    render(createElement(NoApprovalsSection));
+    const toggle = host.querySelector('[role="switch"]');
+    expect(toggle?.getAttribute("aria-checked")).toBe("false");
+    expect(host.querySelector('[role="alertdialog"]')).toBeNull();
+    click(toggle!);
+    const warning = host.querySelector('[role="alertdialog"]');
+    expect(warning?.textContent).toMatch(/hard lines included/);
+    expect(warning?.textContent).toMatch(/permission prompts off/);
+    expect(state.mutate).not.toHaveBeenCalled();
+  });
+
+  it("switches on only when the warning is confirmed, and cancel backs out", () => {
+    render(createElement(NoApprovalsSection));
+    click(host.querySelector('[role="switch"]'));
+    click(byText("Cancel"));
+    expect(host.querySelector('[role="alertdialog"]')).toBeNull();
+    expect(state.mutate).not.toHaveBeenCalled();
+    click(host.querySelector('[role="switch"]'));
+    click(byText("Turn on No approvals"));
+    expect(state.mutate).toHaveBeenCalledWith(true, expect.any(Object));
+  });
+
+  it("switches off at once, and lists what was approved for you", () => {
+    state.on = true;
+    state.audit = [
+      {
+        id: 1,
+        at: "2026-10-13 10:00:00",
+        source: "ask",
+        subject: 'money ask "Pay?"',
+        detail: "",
+      },
+    ];
+    render(createElement(NoApprovalsSection));
+    expect(host.textContent).toContain('money ask "Pay?"');
+    click(host.querySelector('[role="switch"]'));
+    expect(state.mutate).toHaveBeenCalledWith(false);
+  });
+});
+
+describe("the badge", () => {
+  it("shows only while the mode is on", () => {
+    render(createElement(NoApprovalsBadge));
+    expect(host.textContent).toBe("");
+    state.on = true;
+    render(createElement(NoApprovalsBadge));
+    expect(host.textContent).toContain("No approvals");
+  });
+});

package/components/Settings/NoApprovalsSection.tsx

@@ -0,0 +1,103 @@
+"use client";
+
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import { SettingToggle } from "@/components/Settings/SettingToggle";
+import { useApprovalsModeQuery, useSetApprovalsMode } from "@/data/approvals";
+
+// What it switches off, said plainly before it can be switched on.
+export const NO_APPROVALS_WARNING = [
+  "Every ask is approved the moment it is raised, hard lines included: public posts and messages, money, irreversible or destructive changes, credentials.",
+  "A PR that failed its gates twice, has no CI, or is too big to review still merges.",
+  "Brakes stop holding new starts, and plan-only tasks go on to implement without waiting for a plan approval.",
+  "Every agent AgentOS starts runs with its permission prompts off, and prompts already waiting are allowed.",
+];
+
+export function NoApprovalsSection() {
+  const { data, isPending, isError, error } = useApprovalsModeQuery();
+  const set = useSetApprovalsMode();
+  const [confirming, setConfirming] = useState(false);
+
+  if (isPending)
+    return <div className="bg-muted/40 h-16 animate-pulse rounded-lg" />;
+  if (isError)
+    return <p className="text-destructive text-sm">{error.message}</p>;
+
+  return (
+    <div className="space-y-3">
+      <SettingToggle
+        title="No approvals"
+        detail="Shuts off every approval AgentOS would otherwise wait on, and every agent's permission prompts. Off by default."
+        checked={data.on}
+        onChange={(on) => {
+          if (on) setConfirming(true);
+          else set.mutate(false);
+        }}
+      />
+      {confirming && !data.on && (
+        <div
+          role="alertdialog"
+          aria-label="Turn on No approvals"
+          className="rounded-lg border border-red-500/20 bg-red-500/10 p-3"
+        >
+          <p className="mb-2 text-sm font-medium text-red-400">
+            Turn on No approvals?
+          </p>
+          <ul className="text-muted-foreground mb-3 list-disc space-y-1 pl-5 text-xs">
+            {NO_APPROVALS_WARNING.map((line) => (
+              <li key={line}>{line}</li>
+            ))}
+            <li>
+              Terminals already running in an agent other than Claude keep
+              asking until they are restarted. Each approval made for you is
+              logged below.
+            </li>
+          </ul>
+          <div className="flex gap-2">
+            <Button
+              size="sm"
+              variant="destructive"
+              disabled={set.isPending}
+              onClick={() =>
+                set.mutate(true, { onSuccess: () => setConfirming(false) })
+              }
+            >
+              {set.isPending ? "Turning on..." : "Turn on No approvals"}
+            </Button>
+            <Button
+              size="sm"
+              variant="ghost"
+              disabled={set.isPending}
+              onClick={() => setConfirming(false)}
+            >
+              Cancel
+            </Button>
+          </div>
+        </div>
+      )}
+      {set.error && (
+        <p className="text-destructive text-xs">{set.error.message}</p>
+      )}
+      <div>
+        <p className="mb-1 text-sm font-medium">Approved for you</p>
+        {data.audit.length === 0 ? (
+          <p className="text-muted-foreground text-xs">Nothing yet.</p>
+        ) : (
+          <ul className="space-y-1">
+            {data.audit.map((row) => (
+              <li key={row.id} className="text-xs">
+                <span className="text-muted-foreground">
+                  {row.at} · {row.source} ·{" "}
+                </span>
+                {row.subject}
+                {row.detail ? (
+                  <span className="text-muted-foreground"> ({row.detail})</span>
+                ) : null}
+              </li>
+            ))}
+          </ul>
+        )}
+      </div>
+    </div>
+  );
+}

package/components/Settings/SettingsDialog.test.ts

@@ -28,6 +28,9 @@ const stub = (name: string) =>
 vi.mock("@/components/Merge/GlobalMergeSection", () => ({
   GlobalMergeSection: stub("merging"),
 }));
+vi.mock("./NoApprovalsSection", () => ({
+  NoApprovalsSection: stub("approvals"),
+}));
 vi.mock("@/components/Workspaces", () => ({
   WorkspaceSettings: stub("workspaces"),
 }));

package/components/Settings/SettingsDialog.tsx

@@ -13,6 +13,7 @@ import {
   GitMerge,
   LayoutGrid,
   ListChecks,
+  ShieldOff,
   Smartphone,
   X,
   type LucideIcon,
@@ -38,6 +39,7 @@ import { schedulesUiActions } from "@/stores/schedulesUi";
 import { RecipesPanel } from "@/components/Recipes";
 import { settingsUi, settingsUiActions } from "@/stores/settingsUi";
 import { SetupSection } from "./SetupSection";
+import { NoApprovalsSection } from "./NoApprovalsSection";
 import {
   NotificationsSection,
   type BrowserNotifications,
@@ -52,6 +54,11 @@ export const SECTION_INFO: Record<
     hint: "Approval, merge method, branch clean-up",
     icon: GitMerge,
   },
+  approvals: {
+    label: "No approvals",
+    hint: "Switch off every approval and permission prompt",
+    icon: ShieldOff,
+  },
   workspaces: {
     label: "Workspaces",
     hint: "Running task limit",
@@ -104,6 +111,8 @@ function SectionBody({
   switch (section) {
     case "merging":
       return <GlobalMergeSection />;
+    case "approvals":
+      return <NoApprovalsSection />;
     case "workspaces":
       return <WorkspaceSettings />;
     case "models":

package/data/approvals/index.ts

@@ -0,0 +1,56 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { AuditRow } from "@/lib/approvals/no-approvals";
+import { provePresence } from "../presence";
+import { usePollWhenOffline } from "../push/connection";
+
+export interface ApprovalsMode {
+  on: boolean;
+  audit: AuditRow[];
+}
+
+export const approvalsKeys = { all: ["approvals"] as const };
+
+async function json(res: Response): Promise<ApprovalsMode> {
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || "Request failed");
+  return data;
+}
+
+// Shared with the code that builds a terminal's launch command.
+export const approvalsModeQuery = {
+  queryKey: approvalsKeys.all,
+  queryFn: async () => json(await fetch("/api/approvals")),
+  staleTime: 10_000,
+};
+
+export function useApprovalsModeQuery() {
+  return useQuery({
+    ...approvalsModeQuery,
+    refetchInterval: usePollWhenOffline(60_000),
+  });
+}
+
+// Turning it on needs a passkey; turning it off doesn't.
+export function useSetApprovalsMode() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (on: boolean) =>
+      json(
+        await fetch("/api/approvals", {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            on,
+            ...(on
+              ? {
+                  assertion: await provePresence({
+                    purpose: "no-approvals-on",
+                  }),
+                }
+              : {}),
+          }),
+        })
+      ),
+    onSuccess: (data) => queryClient.setQueryData(approvalsKeys.all, data),
+  });
+}

package/lib/approvals/enable.ts

@@ -0,0 +1,64 @@
+// Switching No approvals mode: the one place that turns it on or off and
+// brings what already exists in line with it.
+
+import { db } from "../db";
+import { reapplyChatModes } from "../chat/settings";
+import { approvePlanNow } from "../models/plan-step";
+import { autoApproveAsk, type AskRow } from "../orchestrator/asks";
+import { addNote } from "../orchestrator/notes";
+import { listOrchestrators } from "../orchestrator/home";
+import {
+  noApprovalsOn,
+  recordAutoApproval,
+  setNoApprovals,
+} from "./no-approvals";
+
+// Everything already waiting when the mode goes on is approved: open asks,
+// plan-only tasks at their plan, tool cards in live chats.
+async function sweep(): Promise<void> {
+  const asks = db
+    .prepare(`SELECT * FROM orchestrator_asks WHERE status = 'open'`)
+    .all() as AskRow[];
+  for (const ask of asks) {
+    try {
+      autoApproveAsk(ask.workspace_id, ask);
+    } catch (e) {
+      console.error(`auto-approving ask ${ask.id} failed:`, e);
+    }
+  }
+  const plans = db
+    .prepare(
+      `SELECT id FROM sessions WHERE plan_phase = 'awaiting' AND task_status = 'running'`
+    )
+    .all() as { id: string }[];
+  for (const p of plans) {
+    try {
+      await approvePlanNow(p.id, undefined, "no-approvals");
+    } catch (e) {
+      console.error(`auto-approving plan of ${p.id} failed:`, e);
+    }
+  }
+}
+
+export async function switchNoApprovals(on: boolean): Promise<void> {
+  if (on === noApprovalsOn()) return;
+  setNoApprovals(on);
+  recordAutoApproval({
+    source: "mode",
+    subject: on
+      ? "No approvals mode turned on"
+      : "No approvals mode turned off",
+  });
+  for (const o of listOrchestrators()) {
+    if (!o.workspace_id) continue;
+    addNote(
+      o.workspace_id,
+      on
+        ? "No approvals mode is on: every ask is approved as it's raised, and agents run without permission prompts."
+        : "No approvals mode is off: asks wait for Saad again.",
+      "ask"
+    );
+  }
+  if (on) await sweep();
+  reapplyChatModes();
+}