@saadnvd1/agent-os 0.3.516 → 0.3.518

package/README.md

@@ -914,6 +914,32 @@ line at the bottom of Schedules), one of:
 - **Telegram**: a bot token and your chat id. The token is kept in the
   database and never shown again, returned by the API or logged.
 
+#### Push to the phone app
+
+A machine linked to Connect sends to the paired phones that have registered
+for push, instead of Telegram. A push is generic: the title "AgentOS", a
+category word and a link to open, no session or task text (the payload is a
+versioned envelope, so an encrypted body can replace it later). It goes
+through the Connect relay, signed with the machine key; AgentOS keeps a
+`push_outbox` that retries with backoff, forgets tokens the relay reports as
+dead, and caps alerting pushes at 10 an hour per device (one summary after).
+
+- **What pushes**: an ask raised, a session waiting on you for a minute,
+  a task ready for review, CI or a review failing, a plan ready to approve,
+  and the Away digest. Merged is off by default. Each device picks its
+  categories (`PATCH /api/devices/me/push`). A task mirrored from another
+  machine never pushes from here.
+- **Quiet rules**: waiting, review, CI and merged don't push while you're at
+  this Mac (keyboard or mouse used in the last 3 minutes). While Away is on,
+  everything except asks folds into the 10-minute digest.
+- **Fallback**: agent messages, the Away digest and machine alerts (load,
+  schedules) go to Telegram when push isn't configured or fails. The newer
+  events are push-only. If Connect says push isn't set up yet, AgentOS
+  stops asking for 10 minutes and uses Telegram meanwhile.
+- **Check it**: `aos push test` sends a real push to each registered phone
+  and prints what came back; Settings → Devices shows each device's push
+  state, categories, last error and a Send test button.
+
 ## Agent network
 
 Sessions started by AgentOS can find and talk to each other without you,
@@ -940,6 +966,7 @@ aos schedules                     # every schedule, its next run and last outcom
 aos schedule run <name>           # run a schedule now
 aos schedule add --session <s> --every 30m "prompt"  # check in on a session
 aos notify "text"                 # push a message to your phone
+aos push test                     # a real test push to the paired phones, and the result
 aos heavy -- npm test             # run it now; says first what else heavy is running
 aos stop <session>                # stop its turn now; the next message runs as a new turn
 aos done <session>                # finished: merge through the gates, archive
@@ -1174,7 +1201,7 @@ it may do on its own, and the lines that always come back to you as asks.
 - **Tools:** `sessions` (every session's status, activity, task, PR, CI and
   stack position), `read` (the end of a terminal or chat) and `cards` (the
   linked boards' cards), plus acting tools: `send`, `start_task`,
-  `start_session`, `stack`, `stack_status`, `land`, `drop`, `stop`, `done`,
+  `start_session`, `stack`, `stack_status`, `land`, `drop`, `stop`, `done`, `move`,
   `add_project` (a git repository on the machine becomes a project of the
   workspace, or the project already at that path moves in from no workspace;
   folders that hold secrets and projects of another workspace are refused),
@@ -1195,7 +1222,8 @@ it may do on its own, and the lines that always come back to you as asks.
   naming the tool to use instead: merging, closing or retargeting a PR
   (`gh pr merge`, `gh pr close`, `gh pr edit --base`, and `gh api` or `curl`
   calls that merge a pull request or PATCH or PUT one; use `sign_off`, `arm`,
-  `land` or `drop`), `git push` (`quick_pr` pushes), writing in a project
+  `land` or `drop`), `aos move`, `aos done` and `aos stop` (use `move`, `done` and
+  `stop`, which are scoped to the workspace and held by Pause), `git push` (`quick_pr` pushes), writing in a project
   repository or task worktree other than its own open quick changes (git
   commit, reset, checkout, rebase, merge, stash, clean or rm there, and `rm`,
   `mv`, `cp`, `tee` or a redirect into one), writing AgentOS's state (`sqlite3`
@@ -1547,6 +1575,22 @@ Once linked:
   press Move again to finish it, or **Resume here**, which first asks the
   other machine whether it arrived. Tasks waiting on you (an escalated gate or
   an open ask), card tasks and stacked tasks don't move yet.
+- **An orchestrator's task moves too**, by the orchestrator's `move` tool (`task`,
+  `machine`; `here` brings it back) or the Move button. Its state is re-keyed to
+  the task's new session id in the same step it lands: brief and scope changes,
+  plan file and phase, gate checks and failure counts, asks, wakes, queue
+  order, arm, model and provider. Both machines need an AgentOS that can do
+  it, and the arriving one must have the task's provider. The machine it lands
+  on holds it for the orchestrator's machine alone: only that device can
+  merge, arm, message, stop, done or read it, and the arriving machine's own
+  orchestrator, armed merges and bulk done skip it. The orchestrator keeps
+  judging the PR at its head, reads BLOCKED lines and open approvals from the
+  task's chat there, and gets PR, CI, idle and plan events by polling that
+  machine. Its messages arrive marked as from the orchestrator, never as
+  yours. Guards (write guard, shell deny list, attribution settings) run in
+  the task's worker on either machine, and the task can't merge or push to
+  the default branch. Moving counts toward the brakes and Pause refuses the
+  tool.
 - **A chat task moves the same way**, between turns: a running turn is let
   finish (up to 3 minutes, else the move is refused and it carries on here),
   and one waiting on your answer isn't moved. What's sent to it while its
@@ -1559,7 +1603,7 @@ Once linked:
 Works for any project. Requests to the other machine carry its device token,
 so it can sit behind a proxy that never trusts loopback. Linking needs this
 machine or the tailnet, and only pairs with the ssh target's own host name.
-The orchestrator still starts tasks on its own machine only.
+The orchestrator starts tasks on its own machine and moves them afterwards.
 
 ## Security
 

package/app/api/devices/route.ts

@@ -2,6 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { listDevices } from "@/lib/security/devices";
 import { DEVICE_HEADER, TRUST_HEADER } from "@/lib/security/auth";
 import { demoMode } from "@/lib/security/demo";
+import { pushStatus } from "@/lib/notify/push";
 
 // GET /api/devices - paired devices, and how this request was trusted
 export async function GET(request: NextRequest) {
@@ -10,6 +11,7 @@ export async function GET(request: NextRequest) {
     devices: demoMode()
       ? listDevices().map(({ last_address: _a, user_agent: _u, ...d }) => d)
       : listDevices(),
+    push: pushStatus(),
     current: {
       deviceId: request.headers.get(DEVICE_HEADER),
       via: request.headers.get(TRUST_HEADER),

package/app/api/push/test/route.test.ts

@@ -0,0 +1,112 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const relaySend = vi.fn();
+vi.mock("@/lib/notify/push/relay", () => ({
+  linked: () => true,
+  NOT_LINKED: "this machine isn't linked to Connect",
+  relaySend: (...a: unknown[]) => relaySend(...a),
+}));
+
+const { POST } = await import("./route");
+const { GET } = await import("../../devices/route");
+const { pairPhone, resetPush } = await import("@/lib/notify/push/testing");
+const { db } = await import("@/lib/db");
+
+const post = (body?: unknown) =>
+  POST(
+    new NextRequest("http://x/api/push/test", {
+      method: "POST",
+      body: body === undefined ? undefined : JSON.stringify(body),
+    })
+  );
+
+beforeEach(() => {
+  resetPush();
+  relaySend.mockReset();
+  relaySend.mockImplementation(async (b: { devices: unknown[] }) => ({
+    kind: "results",
+    results: b.devices.map(() => ({ status: "sent" })),
+  }));
+});
+
+describe("POST /api/push/test", () => {
+  it("409s with no phone registered", async () => {
+    expect((await post({})).status).toBe(409);
+    expect(relaySend).not.toHaveBeenCalled();
+  });
+
+  it("404s for a device with no push", async () => {
+    pairPhone();
+    expect((await post({ deviceId: "nope" })).status).toBe(404);
+  });
+
+  it("sends to the named device only and says what happened", async () => {
+    const a = pairPhone();
+    pairPhone();
+    const res = await post({ deviceId: a });
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({
+      results: [{ deviceId: a, status: "sent", error: null }],
+      unavailable: null,
+    });
+    expect(relaySend).toHaveBeenCalledTimes(1);
+  });
+
+  it("explains when push isn't set up", async () => {
+    pairPhone();
+    relaySend.mockResolvedValue({
+      kind: "unavailable",
+      reason: "push isn't set up on the Connect service yet",
+    });
+    const res = await post({});
+    const body = await res.json();
+    expect(body.results[0].status).toBe("failed");
+    expect(body.unavailable).toMatch(/isn't set up/);
+  });
+});
+
+describe("GET /api/devices push status", () => {
+  it("lists each device's push state and categories, never the token", async () => {
+    const id = pairPhone(["asks", "review"]);
+    const res = await GET(new NextRequest("http://x/api/devices"));
+    const body = await res.json();
+    const device = body.devices.find((d: { id: string }) => d.id === id);
+    expect(device.push).toEqual({
+      enabled: true,
+      categories: ["asks", "review"],
+      lastError: null,
+      updatedAt: expect.any(String),
+    });
+    expect(body.push).toEqual({ linked: true, unavailable: null });
+    const token = (
+      db.prepare(`SELECT push_token FROM devices WHERE id = ?`).get(id) as {
+        push_token: string;
+      }
+    ).push_token;
+    expect(JSON.stringify(body)).not.toContain(token);
+    expect(Object.keys(device)).not.toContain("push_token");
+  });
+
+  it("shows a device with no push as off, and a pruned one with its error", async () => {
+    const { mintDevice, pruneDevicePush } =
+      await import("@/lib/security/devices");
+    const off = mintDevice("laptop").device.id;
+    const dead = pairPhone();
+    pruneDevicePush(dead, "token no longer valid (Unregistered)");
+    const body = await (
+      await GET(new NextRequest("http://x/api/devices"))
+    ).json();
+    const by = (id: string) =>
+      body.devices.find((d: { id: string }) => d.id === id).push;
+    expect(by(off)).toMatchObject({
+      enabled: false,
+      categories: [],
+      lastError: null,
+    });
+    expect(by(dead)).toMatchObject({
+      enabled: false,
+      lastError: expect.stringMatching(/Unregistered/),
+    });
+  });
+});

package/app/api/push/test/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from "next/server";
+import { sendTestPush } from "@/lib/notify/push";
+import { listPushDevices } from "@/lib/security/devices";
+import { readCapped } from "@/lib/security/read-capped";
+
+// POST /api/push/test { deviceId? } - a real push to the registered phones
+// now, ignoring the quiet rules, and what the relay said about each.
+export async function POST(request: NextRequest) {
+  let deviceId: string | undefined;
+  try {
+    const text = await readCapped(request, 1024);
+    if (text === null)
+      return NextResponse.json({ error: "Too large" }, { status: 413 });
+    const v = JSON.parse(text || "{}");
+    if (typeof v?.deviceId === "string") deviceId = v.deviceId;
+  } catch {
+    return NextResponse.json({ error: "Bad JSON" }, { status: 400 });
+  }
+  const devices = listPushDevices().filter(
+    (d) => !deviceId || d.id === deviceId
+  );
+  if (!devices.length)
+    return NextResponse.json(
+      {
+        error: deviceId
+          ? "That device has no push registered"
+          : "No phone has push registered yet",
+      },
+      { status: deviceId ? 404 : 409 }
+    );
+  const { results, unavailable } = await sendTestPush(deviceId);
+  if (unavailable && !results.length)
+    return NextResponse.json(
+      { error: `Push isn't available: ${unavailable}` },
+      { status: 409 }
+    );
+  return NextResponse.json({ results, unavailable });
+}

package/app/api/tasks/[id]/arm/route.ts

@@ -1,6 +1,8 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db, type Session } from "@/lib/db";
 import { armTask, setArmed } from "@/lib/orchestrator/armed";
+import { callingDevice } from "@/lib/security/device-me";
+import { heldRefusal } from "@/lib/tasks/held";
 
 // { armed: true } merges the task's PR by itself once every gate passes;
 // false takes that back.
@@ -8,6 +10,9 @@ export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  const held = heldRefusal(id, callingDevice(request));
+  if (held) return NextResponse.json({ error: held }, { status: 403 });
   const { armed } = await request.json().catch(() => ({}));
   if (typeof armed !== "boolean")
     return NextResponse.json(

package/app/api/tasks/[id]/chat-tail/route.ts

@@ -0,0 +1,15 @@
+import { NextRequest } from "next/server";
+import { chatTailText } from "@/lib/orchestrator/read";
+import { heldRoute } from "@/lib/tasks/held-routes";
+
+// GET /api/tasks/:id/chat-tail?lines= - the last lines of its conversation,
+// for the orchestrator that moved it here to read.
+export async function GET(
+  request: NextRequest,
+  ctx: { params: Promise<{ id: string }> }
+) {
+  const lines = Number(request.nextUrl.searchParams.get("lines")) || 60;
+  return heldRoute(request, ctx, async (task) => ({
+    text: task.view === "chat" ? chatTailText(task.id, lines) : "",
+  }));
+}

package/app/api/tasks/[id]/done/route.ts

@@ -0,0 +1,15 @@
+import { NextRequest } from "next/server";
+import { doneSession } from "@/lib/done";
+import { heldRoute } from "@/lib/tasks/held-routes";
+
+// POST /api/tasks/:id/done - its orchestrator finishes it: the agent stops
+// and the worktree goes. Never a merge (noMerge): an open PR is refused
+// here, since only its orchestrator's gates merge it.
+export async function POST(
+  request: NextRequest,
+  ctx: { params: Promise<{ id: string }> }
+) {
+  return heldRoute(request, ctx, async (task) => ({
+    outcome: await doneSession(task.id, { by: "direct", noMerge: true }),
+  }));
+}

package/app/api/tasks/[id]/export/route.ts

@@ -1,5 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { exportOrResume } from "@/lib/tasks/move";
+import { callingDevice } from "@/lib/security/device-me";
+import { heldRefusal } from "@/lib/tasks/held";
 
 // POST /api/tasks/:id/export - stop the agent, push, hand over the task.
 // The caller confirms with /moved, or restarts it here with /resume; if it
@@ -8,10 +10,13 @@ export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  const held = heldRefusal(id, callingDevice(request));
+  if (held) return NextResponse.json({ error: held }, { status: 403 });
   try {
     const { to } = await request.json().catch(() => ({}));
     const bundle = await exportOrResume(
-      (await params).id,
+      id,
       String(to || "another machine").slice(0, 100)
     );
     return NextResponse.json({ bundle });

package/app/api/tasks/[id]/merge/route.ts

@@ -1,5 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { signOffTask } from "@/lib/tasks";
+import { callingDevice } from "@/lib/security/device-me";
+import { heldRefusal } from "@/lib/tasks/held";
 
 // head: merge only if the PR is still at this commit; the answer names the
 // commit it was pinned to, so another machine forwarding a merge can check.
@@ -7,6 +9,9 @@ export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  const held = heldRefusal(id, callingDevice(request));
+  if (held) return NextResponse.json({ error: held }, { status: 403 });
   const { head } = await request.json().catch(() => ({}));
   if (
     head !== undefined &&
@@ -14,7 +19,10 @@ export async function POST(
   )
     return NextResponse.json({ error: "Bad head commit" }, { status: 400 });
   try {
-    const method = await signOffTask((await params).id, { head });
+    const method = await signOffTask(id, {
+      head,
+      device: callingDevice(request),
+    });
     return NextResponse.json({ success: true, head: head ?? null, method });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/app/api/tasks/[id]/message/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest } from "next/server";
+import { statusDetector } from "@/lib/status-detector";
+import { deliver } from "@/lib/bus";
+import { sendChatConfirmed } from "@/lib/chat/runner";
+import { cleanRemoteText } from "@/lib/hosts/remote-api";
+import { heldRoute } from "@/lib/tasks/held-routes";
+
+const MAX_LINE = 40_000;
+
+// POST /api/tasks/:id/message {id?, line, from} - the orchestrator that moved
+// this task here speaks to it. It arrives as that orchestrator's message,
+// never as the user's, and a repeat of the same id is not delivered twice.
+export async function POST(
+  request: NextRequest,
+  ctx: { params: Promise<{ id: string }> }
+) {
+  const body = await request.json().catch(() => ({}));
+  return heldRoute(request, ctx, async (task) => {
+    const line = typeof body.line === "string" ? body.line.trim() : "";
+    if (!line || line.length > MAX_LINE) throw new Error("Bad message");
+    const id = typeof body.id === "string" ? body.id.slice(0, 100) : undefined;
+    const from = cleanRemoteText(body.from).slice(0, 100) || "the orchestrator";
+    const label = `${from} on ${task.held_from ?? "another machine"}`;
+    if (task.view === "chat") {
+      const state = await sendChatConfirmed(task.id, {
+        id,
+        text: line,
+        from: label,
+        origin: { kind: "peer", label },
+        compact: "auto",
+      });
+      return { state };
+    }
+    await statusDetector.refreshCache();
+    const delivery = await deliver(task, line, { name: label });
+    if (delivery.state === "failed") throw new Error(delivery.why);
+    return { state: delivery.state };
+  });
+}

package/app/api/tasks/[id]/moved/route.ts

@@ -1,12 +1,17 @@
 import { NextRequest, NextResponse } from "next/server";
 import { markMoved } from "@/lib/tasks/move";
+import { callingDevice } from "@/lib/security/device-me";
+import { heldRefusal } from "@/lib/tasks/held";
 
 // POST /api/tasks/:id/moved - the task now runs on the machine named `to`
 export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  const held = heldRefusal(id, callingDevice(request));
+  if (held) return NextResponse.json({ error: held }, { status: 403 });
   const { to } = await request.json().catch(() => ({}));
-  markMoved((await params).id, String(to || "another machine").slice(0, 100));
+  markMoved(id, String(to || "another machine").slice(0, 100));
   return NextResponse.json({ success: true });
 }

package/app/api/tasks/[id]/resume/route.ts

@@ -1,5 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { resumeHere } from "@/lib/tasks/move-recover";
+import { callingDevice } from "@/lib/security/device-me";
+import { heldRefusal } from "@/lib/tasks/held";
 
 // POST /api/tasks/:id/resume {force?} - start its agent again here, on its
 // conversation. A task left moving asks its target first unless forced.
@@ -7,9 +9,12 @@ export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  const held = heldRefusal(id, callingDevice(request));
+  if (held) return NextResponse.json({ error: held }, { status: 403 });
   const { force } = await request.json().catch(() => ({}));
   try {
-    const result = await resumeHere((await params).id, force === true);
+    const result = await resumeHere(id, force === true);
     return NextResponse.json({ success: true, ...result });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/app/api/tasks/[id]/stop/route.ts

@@ -0,0 +1,14 @@
+import { NextRequest } from "next/server";
+import { stopSession } from "@/lib/sessions/stop";
+import { heldRoute } from "@/lib/tasks/held-routes";
+
+// POST /api/tasks/:id/stop - its orchestrator stops the agent; the
+// conversation and worktree are kept.
+export async function POST(
+  request: NextRequest,
+  ctx: { params: Promise<{ id: string }> }
+) {
+  return heldRoute(request, ctx, async (task) => ({
+    text: await stopSession(task),
+  }));
+}

package/app/api/tasks/import/route.ts

@@ -1,4 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
+import { callingDevice } from "@/lib/security/device-me";
 import { importTask } from "@/lib/tasks/import";
 import { MAX_BUNDLE_BYTES, statusFor } from "@/lib/tasks/move-bundle";
 
@@ -11,7 +12,16 @@ export async function POST(request: NextRequest) {
       { status: 413 }
     );
   try {
-    const session = await importTask(await request.json());
+    const bundle = await request.json();
+    // An orchestrator's task is held for the device that sent it, which
+    // only a paired device is.
+    const holder = callingDevice(request);
+    if (bundle?.orchestrated && !holder)
+      return NextResponse.json(
+        { error: "An orchestrator's task comes only from a paired machine" },
+        { status: 403 }
+      );
+    const session = await importTask(bundle, { holder });
     return NextResponse.json({ session }, { status: 201 });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/components/Devices/DeviceRow.tsx

@@ -2,8 +2,13 @@
 
 import { Laptop, Smartphone, Tablet, Trash2 } from "lucide-react";
 import { Button } from "@/components/ui/button";
-import type { Device } from "@/lib/security/devices";
-import { useRevokeDevice, useSetCanApprove } from "@/data/devices";
+import type { ListedDevice } from "@/lib/security/devices";
+import { CATEGORIES } from "@/lib/notify/copy";
+import {
+  useRevokeDevice,
+  useSendTestPush,
+  useSetCanApprove,
+} from "@/data/devices";
 import { Switch } from "@/components/ui/switch";
 
 // SQLite's datetime('now') is UTC without a zone.
@@ -31,13 +36,22 @@ export function DeviceRow({
   isCurrent,
   canManage,
 }: {
-  device: Device;
+  device: ListedDevice;
   isCurrent: boolean;
   // Only this machine or the tailnet may let a device approve asks.
   canManage: boolean;
 }) {
   const revoke = useRevokeDevice();
   const setCanApprove = useSetCanApprove();
+  const sendTest = useSendTestPush();
+  const tested = sendTest.data?.results[0];
+  const testNote = sendTest.isError
+    ? sendTest.error.message
+    : tested
+      ? tested.status === "sent"
+        ? "Test sent"
+        : `Test failed: ${tested.error}`
+      : null;
 
   const onRevoke = () => {
     if (
@@ -64,7 +78,42 @@ export function DeviceRow({
           {lastSeen(device.last_seen_at)}
           {device.last_address ? ` · ${device.last_address}` : ""}
         </p>
+        {device.push.enabled && (
+          <p className="text-muted-foreground truncate text-xs">
+            Push on ·{" "}
+            {device.push.categories
+              .map((c) => CATEGORIES[c].label)
+              .join(", ") || "nothing selected"}
+          </p>
+        )}
+        {device.push.lastError && (
+          <p
+            className="text-destructive truncate text-xs"
+            title={device.push.lastError}
+          >
+            Push error: {device.push.lastError}
+          </p>
+        )}
+        {testNote && (
+          <p
+            className={`truncate text-xs ${tested?.status === "sent" ? "text-muted-foreground" : "text-destructive"}`}
+            role="status"
+          >
+            {testNote}
+          </p>
+        )}
       </div>
+      {device.push.enabled && (
+        <Button
+          variant="outline"
+          size="sm"
+          className="h-11 shrink-0 sm:h-8"
+          onClick={() => sendTest.mutate(device.id)}
+          disabled={sendTest.isPending}
+        >
+          {sendTest.isPending ? "Sending…" : "Send test"}
+        </Button>
+      )}
       <label className="text-muted-foreground flex min-h-11 shrink-0 items-center gap-2 text-xs sm:min-h-8">
         Can approve
         <Switch

package/components/Devices/DevicesPanel.tsx

@@ -43,6 +43,19 @@ export function DevicesPanel() {
         )
       )}
 
+      {data && !data.push.linked && (
+        <p className="text-muted-foreground text-sm">
+          Phone push needs this machine linked to Connect. Until then,
+          notifications go to Telegram if it&apos;s set up.
+        </p>
+      )}
+      {data?.push.unavailable && (
+        <p className="text-destructive text-sm">
+          Push is paused: {data.push.unavailable}. Notifications go to Telegram
+          meanwhile.
+        </p>
+      )}
+
       <div className="space-y-2">
         {isPending && (
           <div className="bg-muted/40 h-14 animate-pulse rounded-lg" />

package/data/devices/queries.ts

@@ -1,5 +1,5 @@
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import type { Device } from "@/lib/security/devices";
+import type { ListedDevice } from "@/lib/security/devices";
 import type { NetworkState } from "@/lib/security/network-state";
 import type { PairingOffer } from "@/lib/security/pair-qr";
 import { deviceKeys } from "./keys";
@@ -12,7 +12,9 @@ async function json<T>(res: Response): Promise<T> {
 }
 
 export interface DevicesResponse {
-  devices: Device[];
+  devices: ListedDevice[];
+  // Whether this machine can reach the push relay at all.
+  push: { linked: boolean; unavailable: string | null };
   current: { deviceId: string | null; via: string | null };
 }
 
@@ -128,3 +130,29 @@ export function useSetCanApprove() {
       queryClient.invalidateQueries({ queryKey: deviceKeys.list() }),
   });
 }
+
+export interface PushTestResponse {
+  results: {
+    deviceId: string;
+    status: "sent" | "gone" | "failed";
+    error: string | null;
+  }[];
+  unavailable: string | null;
+}
+
+export function useSendTestPush() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (deviceId: string) =>
+      json<PushTestResponse>(
+        await fetch("/api/push/test", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ deviceId }),
+        })
+      ),
+    // A dead token is forgotten, and the last error changes.
+    onSettled: () =>
+      queryClient.invalidateQueries({ queryKey: deviceKeys.list() }),
+  });
+}