@saadnvd1/agent-os 0.3.516 → 0.3.517

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

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/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() }),
+  });
+}

package/lib/away/run.ts

@@ -19,6 +19,7 @@ import { review } from "../orchestrator/review";
 import { repoOf } from "../orchestrator/repo";
 import { clip } from "../orchestrator/digest";
 import { notifyPhone } from "../notify";
+import { takeFoldedPushes } from "../notify/push";
 import { getProject } from "../projects";
 import { loadProjectConfig } from "../project-config";
 import { run } from "../tasks/gh";
@@ -194,7 +195,11 @@ export function turnAwayOff(
   // no report), then the summary. A second later, so the window takes
   // everything up to now.
   notifyBatch(ended, now + 1000);
-  notifyPhone(PHONE_SOURCE, phoneSummary(report));
+  notifyPhone(PHONE_SOURCE, phoneSummary(report), {
+    category: "digest",
+    key: `digest:end:${ended.id}`,
+    collapse: "digest",
+  });
   return { ...ended, report: JSON.stringify(report) };
 }
 
@@ -516,7 +521,9 @@ export function notifyBatch(away: AwayRow, now = Date.now()): string | null {
   }[];
   const deploys = held.filter((h) => h.kind === "deploy_failed");
   const notes = held.filter((h) => h.kind === "notify");
-  if (!asks.length && !held.length) return null;
+  // What push held for this digest (ready for review, CI, agent messages).
+  const pushed = takeFoldedPushes(now);
+  if (!asks.length && !held.length && !pushed) return null;
   const lines = [
     ...deploys.map(
       (d) => `- ${d.workspace}: deploy failed: ${clip(d.detail ?? "", 120)}`
@@ -534,6 +541,7 @@ export function notifyBatch(away: AwayRow, now = Date.now()): string | null {
       "note from an orchestrator",
       "notes from orchestrators"
     ),
+    ...count(pushed, "other update", "other updates"),
   ];
   const head = `While you're away: ${parts.length > 1 ? `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}` : parts[0]}`;
   const shown = lines.slice(0, PHONE_LINES);
@@ -541,7 +549,11 @@ export function notifyBatch(away: AwayRow, now = Date.now()): string | null {
   const text = [head, ...shown, ...(more ? [`- and ${more} more`] : [])].join(
     "\n"
   );
-  notifyPhone(PHONE_SOURCE, text);
+  notifyPhone(PHONE_SOURCE, text, {
+    category: "digest",
+    key: `digest:${away.id}:${now}`,
+    collapse: "digest",
+  });
   return text;
 }
 

package/lib/chat/registry.ts

@@ -1,3 +1,4 @@
+import { noteWaiting } from "../notify/push/waiting";
 import { db, type Session } from "../db";
 import type { WorkerClient } from "./worker/client";
 import { notifyStatusChanged } from "../status/hub";
@@ -90,6 +91,7 @@ export function emit(sessionId: string, m: ChatServerMessage): void {
   // Items come from the worker, which writes them a moment after saying so.
   if (m.type === "state" || m.type === "compacting" || m.type === "item")
     markStatusDirty(sessionId, EMIT_SETTLE_MS);
+  if (m.type === "state") noteWaiting(sessionId, m.state === "waiting");
   registry.listeners.get(sessionId)?.forEach((fn) => fn(m));
   // Idle, running, waiting and back, and a finished turn (unread): the
   // sidebar hears at once.

package/lib/chat/runner.ts

@@ -5,6 +5,7 @@
  * events to whoever is watching. Restarting the server leaves turns running.
  */
 
+import { pushPlanReady } from "../notify/push/events";
 import { handoffAfterPlan } from "../models/plan-step";
 import { randomUUID } from "crypto";
 import os from "os";
@@ -152,6 +153,8 @@ function onWorkerEvent(sessionId: string, live: Live, e: WorkerEvent): void {
   if (e.type === "item" && e.item.kind === "task")
     retireIfStale(sessionId, live);
   if (e.type === "item") {
+    if (e.item.kind === "plan" && !e.item.carried)
+      pushPlanReady(sessionId, e.item.id);
     if ("streaming" in e.item && e.item.streaming)
       live.streaming.set(e.item.id, e.item);
     else live.streaming.delete(e.item.id);

package/lib/connect/control-api.ts

@@ -226,3 +226,41 @@ export async function heartbeat(
   );
   return (await res.json()) as { enabled: boolean };
 }
+
+export interface PushRequestBody {
+  v: 1;
+  devices: { token: string; env: "production" | "sandbox" }[];
+  push_type: "alert" | "background";
+  priority: 10 | 5;
+  level: "passive" | "active" | "time-sensitive";
+  collapse_id?: string;
+  thread_id?: string;
+  payload: Record<string, unknown>;
+}
+
+export interface PushResult {
+  status: "sent" | "gone" | "retry" | "rejected";
+  apns_status?: number;
+  reason?: string;
+  prune?: boolean;
+  retry_after?: number;
+}
+
+/** One APNs send per device, answered in device order. Signed. */
+export async function pushRelay(
+  config: ConnectConfig,
+  privateKey: string,
+  body: PushRequestBody
+): Promise<PushResult[]> {
+  const res = await signed(config, privateKey)(
+    "POST",
+    `/api/v1/machines/${config.machineId}/push`,
+    body
+  );
+  const r = (await res.json().catch(() => null)) as {
+    results?: PushResult[];
+  } | null;
+  if (!Array.isArray(r?.results))
+    throw new Error("the Connect service sent no push results");
+  return r.results;
+}

package/lib/db/migrations.ts

@@ -1658,6 +1658,37 @@ const migrations: Migration[] = [
       );
     },
   },
+  {
+    id: 72,
+    name: "push_outbox",
+    up: (db) => {
+      // One row per (event, device). device_id is '' for a row folded into
+      // the Away digest. state: pending, sending, sent, failed, gone,
+      // capped, superseded, folded, digested.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS push_outbox (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          event_key TEXT NOT NULL,
+          device_id TEXT NOT NULL,
+          category TEXT NOT NULL,
+          level TEXT NOT NULL,
+          payload TEXT NOT NULL,
+          collapse_id TEXT,
+          state TEXT NOT NULL,
+          attempts INTEGER NOT NULL DEFAULT 0,
+          next_attempt_at INTEGER NOT NULL,
+          created_at INTEGER NOT NULL,
+          sent_at INTEGER,
+          error TEXT,
+          fallback_source TEXT,
+          fallback_text TEXT,
+          UNIQUE(event_key, device_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_push_outbox_due ON push_outbox(state, next_attempt_at);
+        CREATE INDEX IF NOT EXISTS idx_push_outbox_device ON push_outbox(device_id, sent_at);
+      `);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/done/index.ts

@@ -26,6 +26,7 @@ import { releasePorts } from "../ports";
 import { dropSessionDatabase } from "../project-config/database";
 import { doneOnPeer, peerSessionLink } from "../hosts/peer-actions";
 import { captureMergedTask } from "../session-logs";
+import { pushMerged } from "../notify/push/events";
 
 export interface DoneOptions {
   // Who asked: the orchestrator's gate failures count toward Saad, as its
@@ -103,7 +104,10 @@ function mark(s: Session, status: "merged" | "done", pr: TaskPR | null) {
       : `UPDATE sessions SET task_status = 'done' WHERE id = ?`
   ).run(s.id);
   syncTaskCardInBackground(s, status, pr);
-  if (status === "merged") void captureMergedTask(s.id, { head: pr?.head });
+  if (status === "merged") {
+    pushMerged(s.id);
+    void captureMergedTask(s.id, { head: pr?.head });
+  }
 }
 
 export async function doneSession(

package/lib/load/alert.ts

@@ -30,7 +30,11 @@ const BACK_OFF =
   "Ask your running tasks to use targeted tests and hold off on full suites, type checks and builds until it clears. Nothing has been stopped.";
 
 export function raiseAlert(text: string): void {
-  notifyPhone("load", text);
+  notifyPhone("load", text, {
+    category: "system",
+    key: `system:load:${Date.now()}`,
+    collapse: "system:load",
+  });
   for (const orch of listOrchestrators()) {
     if (orch.archived_at) continue;
     sendMessage({

package/lib/notify/index.ts

@@ -9,6 +9,9 @@ import { db, type Session } from "../db";
 import { Limiter, type Outcome } from "./limiter";
 import { holdForBatch, msToNextSweep } from "../away/state";
 import { selectNotifier, type TelegramConfig } from "./notifiers";
+import { pushAvailable, pushEvent } from "./push";
+import { setFallbackSink } from "./push/sender";
+import type { PushCategory } from "./push-types";
 
 export type { Outcome } from "./limiter";
 
@@ -99,6 +102,23 @@ export function resumePhoneOutbox(): void {
   }
 }
 
+// Held text that push couldn't deliver goes to Telegram once.
+setFallbackSink(async (source, text) => {
+  const outcome = await limiter().push(source, text);
+  if (outcome.state === "failed") throw new Error(outcome.why);
+});
+
+// Which phone-app category a message belongs to. A message with one goes to
+// a registered device instead of Telegram, and to Telegram if push is off.
+export interface PushRoute {
+  category: PushCategory;
+  id?: string | null;
+  key?: string | null;
+  collapse?: string | null;
+  /** The session it is about, so a mirror of another machine's never pushes. */
+  sessionId?: string | null;
+}
+
 export class NotConfigured extends Error {
   constructor() {
     super(
@@ -111,10 +131,21 @@ export class NotConfigured extends Error {
 // NotConfigured when nothing would send it.
 export async function sendPhone(
   source: string,
-  text: string
+  text: string,
+  push?: PushRoute
 ): Promise<Outcome> {
   const body = text.trim();
   if (!body) throw new Error("Nothing to send");
+  if (push && pushAvailable()) {
+    const { sessionId, ...event } = push;
+    const out = await pushEvent(event, {
+      sessionId,
+      fallback: { source, text: body },
+    });
+    if (out === "queued") return { state: "pushed" };
+    if (out === "folded") return { state: "held", inMs: msToNextSweep() };
+    if (out === "dropped" || out === "muted") return { state: "skipped" };
+  }
   if (!selectNotifier(process.env, telegramConfig())) throw new NotConfigured();
   const outcome = await limiter().push(source, body);
   if (outcome.state === "failed")
@@ -142,15 +173,23 @@ export async function notifyFrom(
     holdForBatch(session.workspace_id, session.id, body)
   )
     return { state: "held", inMs: msToNextSweep() };
-  return sendPhone(
-    session ? `session:${session.id}` : "cli",
-    session ? `${session.name}: ${body}` : body
-  );
+  const source = session ? `session:${session.id}` : "cli";
+  return sendPhone(source, session ? `${session.name}: ${body}` : body, {
+    category: "agents",
+    id: session?.id,
+    key: `agents:${session?.id ?? "cli"}:${Date.now()}`,
+    collapse: `agents:${session?.id ?? "cli"}`,
+    sessionId: session?.id,
+  });
 }
 
 // For the server's own alerts: never throws, never waits on the send.
-export function notifyPhone(source: string, text: string): void {
-  sendPhone(source, text).catch((error) => {
+export function notifyPhone(
+  source: string,
+  text: string,
+  push?: PushRoute
+): void {
+  sendPhone(source, text, push).catch((error) => {
     if (!(error instanceof NotConfigured))
       console.error(
         `[notify] ${source}:`,

package/lib/notify/limiter.ts

@@ -16,7 +16,12 @@ export type Outcome =
   | { state: "held"; inMs: number }
   | { state: "duplicate" }
   | { state: "dropped" }
-  | { state: "failed"; why: string };
+  | { state: "failed"; why: string }
+  // Went to the phone app; Telegram only steps in if that fails.
+  | { state: "pushed" }
+  // Push had nothing to do: the device turned the category off, or Saad is
+  // at the Mac.
+  | { state: "skipped" };
 
 export function collapse(texts: string[]): string {
   if (texts.length === 1) return texts[0];