@saadnvd1/agent-os 0.3.570 → 0.3.572

package/README.md

@@ -13,7 +13,7 @@ and check on all of it from your phone.
 ## What it does
 
 - **An orchestrator for each workspace.** A chat that starts tasks, answers blocked agents, and merges pull requests only through gates. Anything that is yours to decide waits as an ask. [More](docs/reference/orchestrator.md)
-- **Tasks that end in a pull request.** Each gets its own worktree, branch and ports, runs the project's code review, and waits for your sign-off. [More](docs/guides/tasks.md)
+- **Tasks that end in a pull request.** Each gets its own worktree, branch and ports, runs the project's code review, and waits for your sign-off. A queue ranks waiting tasks by priority and machine load, can start one on a linked machine when this one is busy, and a running task can be paused for a set time and resumes by itself. [More](docs/guides/tasks.md)
 - **Each kind of work on the right model.** Planning, review, implementation and titles each run on their own model, set in Settings → Models. [More](docs/reference/model-routing.md)
 - **Nothing starts until you send.** ⌥N opens a draft with project, machine, agent and branch as chips. [More](docs/guides/sessions.md)
 - **Other machines in the same list.** Link another machine that runs AgentOS and start or move work there. [More](docs/reference/machines.md)

package/app/api/bus/spawn/route.ts

@@ -1,7 +1,8 @@
 import { NextRequest, NextResponse } from "next/server";
 import { spawnSession, findProject } from "@/lib/agents/spawn";
 import { createTask } from "@/lib/tasks";
-import { startOrQueue } from "@/lib/tasks/queue";
+import { startOrQueue, stampPriority } from "@/lib/tasks/queue";
+import { isPriority } from "@/lib/tasks/schedule-types";
 import { hostIdNamed } from "@/lib/hosts";
 import { startView } from "@/lib/sessions/launch";
 import { db } from "@/lib/db";
@@ -30,6 +31,8 @@ export async function POST(request: NextRequest) {
       after,
       view,
       planOnly,
+      priority,
+      machine,
       from,
     } = await request.json();
     const startedBy = orchestratorFrom(from);
@@ -38,6 +41,12 @@ export async function POST(request: NextRequest) {
       throw new Error("--after works for tasks only");
     if (planOnly !== undefined && mode !== "task")
       throw new Error("--plan-only works for tasks only");
+    if ((priority !== undefined || machine !== undefined) && mode !== "task")
+      throw new Error("--priority and --on-mac work for tasks only");
+    if (priority !== undefined && !isPriority(priority))
+      throw new Error("--priority is urgent, blocking, normal or background");
+    if (machine !== undefined && machine !== "mac" && machine !== "any")
+      throw new Error('machine is "mac" or "any"');
     if (mode === "task") {
       const task = {
         projectId: findProject(String(project ?? "")).id,
@@ -50,8 +59,17 @@ export async function POST(request: NextRequest) {
         startedBy,
       };
       const out = await startOrQueue(
-        { ...task, after: typeof after === "string" ? after : undefined },
-        () => createTask(task)
+        {
+          ...task,
+          after: typeof after === "string" ? after : undefined,
+          priority,
+          machine,
+        },
+        async () => {
+          const session = await createTask(task);
+          stampPriority(session.id, priority);
+          return session;
+        }
       );
       return "queued" in out
         ? NextResponse.json({ queued: out.queued }, { status: 202 })

package/app/api/client-config/route.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { GET } from "./route";
+
+describe("GET /api/client-config", () => {
+  it("serves the config uncached", async () => {
+    const res = GET();
+    expect(res.status).toBe(200);
+    expect(res.headers.get("cache-control")).toBe("no-store");
+    expect((await res.json()).v).toBe(1);
+  });
+});

package/app/api/client-config/route.ts

@@ -0,0 +1,10 @@
+import { NextResponse } from "next/server";
+import { clientConfig } from "@/lib/config/client-config";
+
+// GET /api/client-config - the labels and defaults a client renders with.
+// Read-only; the app keeps its own cache, so the server never does.
+export function GET() {
+  return NextResponse.json(clientConfig(), {
+    headers: { "Cache-Control": "no-store" },
+  });
+}

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

@@ -0,0 +1,32 @@
+import { describe, expect, it, vi } from "vitest";
+
+const facts = vi.hoisted(() => ({ level: null as string | null }));
+vi.mock("@/lib/load/machines", () => ({
+  localFacts: () => ({
+    level: facts.level,
+    load1: 1,
+    cores: 8,
+    memUsedPct: 40,
+    booted: 0,
+    capabilities: ["linux"],
+  }),
+}));
+
+import { GET } from "./route";
+import { parseReading } from "@/lib/hosts/peer-load";
+
+describe("GET /api/load", () => {
+  it("reports no level before the first sample, and the asker reads that as no reading", async () => {
+    facts.level = null;
+    const body = await GET().json();
+    expect(body.level).toBeNull();
+    expect(parseReading(body, 1)).toBeNull();
+  });
+
+  it("reports the level once it has one", async () => {
+    facts.level = "amber";
+    const body = await GET().json();
+    expect(body).toMatchObject({ level: "amber", cores: 8 });
+    expect(parseReading(body, 1)).toMatchObject({ level: "amber" });
+  });
+});

package/app/api/load/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from "next/server";
+import { localFacts } from "@/lib/load/machines";
+
+export const dynamic = "force-dynamic";
+
+// This machine's load as the scheduler reads it, for another machine's
+// AgentOS deciding whether to start a task here. No session names or paths.
+// Before the monitor's first sample the level is null, which the asker
+// reads as no reading (held), never as green.
+export function GET() {
+  const f = localFacts();
+  return NextResponse.json({
+    level: f.level,
+    load1: f.load1,
+    cores: f.cores,
+    memUsedPct: f.memUsedPct,
+    booted: f.booted,
+    capabilities: f.capabilities,
+  });
+}

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

@@ -0,0 +1,97 @@
+import { NextResponse } from "next/server";
+import {
+  PauseRefused,
+  pauseViewOf,
+  requestPause,
+  resumeNow,
+  setResumeTime,
+} from "@/lib/tasks/pause";
+
+const MAX_AHEAD_MS = 60 * 24 * 3600_000;
+
+function parseUntil(v: unknown): Date | null | "bad" {
+  if (v === null) return null;
+  const at = typeof v === "string" ? new Date(v) : new Date(NaN);
+  const ahead = at.getTime() - Date.now();
+  return Number.isNaN(ahead) || ahead < 0 || ahead > MAX_AHEAD_MS ? "bad" : at;
+}
+
+const fail = (error: unknown) =>
+  NextResponse.json(
+    { error: error instanceof Error ? error.message : String(error) },
+    { status: error instanceof PauseRefused ? 409 : 500 }
+  );
+
+// POST /api/sessions/:id/pause { until, mode } - pauses it: until an ISO time
+// (the reader's own 9am, worked out on their device), or null for until it is
+// resumed. mode "turn" (the default) stops it at the end of its step; "now"
+// interrupts the step. Refused with 409 and the reason when it can't be.
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = (await request.json().catch(() => null)) as {
+    until?: unknown;
+    mode?: unknown;
+  } | null;
+  if (body?.until === undefined)
+    return NextResponse.json({ error: "until is required" }, { status: 400 });
+  const until = parseUntil(body.until);
+  if (until === "bad")
+    return NextResponse.json(
+      { error: "until must be a time within the next 60 days" },
+      { status: 400 }
+    );
+  if (body.mode !== undefined && body.mode !== "turn" && body.mode !== "now")
+    return NextResponse.json(
+      { error: 'mode is "turn" or "now"' },
+      { status: 400 }
+    );
+  try {
+    requestPause(id, { until, mode: body.mode ?? "turn", by: "person" });
+    return NextResponse.json({ pause: pauseViewOf(id) }, { status: 202 });
+  } catch (error) {
+    return fail(error);
+  }
+}
+
+// PATCH /api/sessions/:id/pause { until } - changes when it resumes.
+export async function PATCH(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = (await request.json().catch(() => null)) as {
+    until?: unknown;
+  } | null;
+  if (body?.until === undefined)
+    return NextResponse.json({ error: "until is required" }, { status: 400 });
+  const until = parseUntil(body.until);
+  if (until === "bad")
+    return NextResponse.json(
+      { error: "until must be a time within the next 60 days" },
+      { status: 400 }
+    );
+  try {
+    setResumeTime(id, until);
+    return NextResponse.json({ pause: pauseViewOf(id) });
+  } catch (error) {
+    return fail(error);
+  }
+}
+
+// DELETE /api/sessions/:id/pause - resume now (past the task limit), or keep
+// running when it is still pausing.
+export async function DELETE(
+  _request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  try {
+    await resumeNow(id, "person");
+    return NextResponse.json({ pause: pauseViewOf(id) });
+  } catch (error) {
+    return fail(error);
+  }
+}

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

@@ -0,0 +1,29 @@
+import { NextResponse } from "next/server";
+import { setPriority } from "@/lib/tasks/queue";
+import { isPriority } from "@/lib/tasks/schedule-types";
+
+// PATCH /api/tasks/:id/priority { priority } - urgent, blocking, normal or
+// background, for a queued task or a running one. A queued task keeps its age.
+export async function PATCH(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = (await request.json().catch(() => null)) as {
+    priority?: unknown;
+  } | null;
+  if (!isPriority(body?.priority))
+    return NextResponse.json(
+      { error: "priority is one of: urgent, blocking, normal, background" },
+      { status: 400 }
+    );
+  try {
+    setPriority(id, body.priority);
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 404 }
+    );
+  }
+  return NextResponse.json({ ok: true, priority: body.priority });
+}

package/app/api/tasks/route.ts

@@ -1,7 +1,8 @@
 import { parseOverride } from "@/lib/models/resolve";
 import { NextRequest, NextResponse } from "next/server";
 import { createTask, listTasks, movedTasks } from "@/lib/tasks";
-import { startOrQueue } from "@/lib/tasks/queue";
+import { stampPriority, startOrQueue } from "@/lib/tasks/queue";
+import { isPriority } from "@/lib/tasks/schedule-types";
 import { TASK_CAPABILITIES } from "@/lib/tasks/remote";
 import { ensureProject, type ProjectRef } from "@/lib/tasks/project-ref";
 import { isSessionId, statusFor } from "@/lib/tasks/move-bundle";
@@ -40,12 +41,20 @@ export async function POST(request: NextRequest) {
       plan,
       plan_reason,
       plan_only,
+      priority,
+      machine,
     } = await request.json();
     if (id !== undefined && !isSessionId(id)) throw new Error("Bad task id");
     const pid =
       project && typeof project === "object"
         ? (await ensureProject(project as ProjectRef)).id
         : projectId;
+    if (priority !== undefined && !isPriority(priority))
+      throw new Error(
+        "Priority is one of: urgent, blocking, normal, background"
+      );
+    if (machine !== undefined && machine !== "any" && machine !== "mac")
+      throw new Error('Machine is "any" or "mac"');
     if (agent !== undefined && !isValidAgentType(agent))
       throw new Error("Unknown agent");
     if (agent && agent !== "claude" && model != null && model !== "")
@@ -76,12 +85,18 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ session }, { status: 201 });
     }
     const out = await startOrQueue(
-      { ...opts, after: typeof after === "string" ? after : undefined },
+      {
+        ...opts,
+        after: typeof after === "string" ? after : undefined,
+        priority,
+        machine,
+      },
       () => createTask(opts)
     );
     if ("queued" in out)
       return NextResponse.json({ queued: out.queued }, { status: 202 });
     const session = out.started;
+    stampPriority(session.id, priority);
     return NextResponse.json({ session }, { status: 201 });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/components/Chat/AccessPicker.tsx

@@ -14,28 +14,20 @@ import {
   DropdownMenuItem,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
+import { ACCESS_LEVELS } from "@/lib/chat/access-levels";
 import { CHAT_ACCESS, type ChatAccess } from "@/lib/chat/events";
 
-const LEVELS: Record<
+const ICON: Record<ChatAccess, typeof Shield> = {
+  ask: ShieldCheck,
+  edits: Shield,
+  full: ShieldOff,
+};
+const LEVELS = Object.fromEntries(
+  CHAT_ACCESS.map((a) => [a, { ...ACCESS_LEVELS[a], icon: ICON[a] }])
+) as Record<
   ChatAccess,
   { label: string; description: string; icon: typeof Shield }
-> = {
-  ask: {
-    label: "Ask first",
-    description: "Asks before edits and commands it isn't already allowed",
-    icon: ShieldCheck,
-  },
-  edits: {
-    label: "Accept edits",
-    description: "Edits files on its own, asks before other commands",
-    icon: Shield,
-  },
-  full: {
-    label: "Full access",
-    description: "Does everything without asking",
-    icon: ShieldOff,
-  },
-};
+>;
 
 // What the agent may do without asking, switchable mid-conversation.
 export function AccessPicker({

package/components/Chat/ChatPanel.tsx

@@ -12,6 +12,7 @@ import {
 import { ArrowDown, Loader2 } from "lucide-react";
 import type { ClipboardEvent } from "react";
 import { useChat } from "@/data/chat/useChat";
+import { PausedBanner } from "./PausedBanner";
 import {
   groupTimeline,
   sameBlock,
@@ -265,6 +266,7 @@ export function ChatPanel({
     refreshingCommands,
     models,
     model,
+    modelLabel,
     send,
     interrupt,
     setModel,
@@ -715,6 +717,7 @@ export function ChatPanel({
             setInsert({ text: quoteMarkdown(text), at: Date.now() })
           }
         />
+        <PausedBanner sessionId={sessionId} />
         <Queue
           queue={queue}
           running={running}
@@ -770,6 +773,7 @@ export function ChatPanel({
           refreshingCommands={refreshingCommands}
           models={models}
           model={model}
+          modelLabel={modelLabel}
           onSetModel={setModel}
           access={access}
           onSetAccess={accessLocked ? undefined : setAccess}

package/components/Chat/ModelPicker.tsx

@@ -9,20 +9,26 @@ import {
 } from "@/components/ui/dropdown-menu";
 import type { ChatModel } from "@/lib/chat/events";
 
-export function modelLabel(models: ChatModel[], value: string): string {
-  return models.find((m) => m.value === value)?.label ?? value;
+export function modelLabel(
+  models: ChatModel[],
+  value: string,
+  serverLabel?: string
+): string {
+  return models.find((m) => m.value === value)?.label ?? (serverLabel || value);
 }
 
 // The session's model, switchable mid-conversation. Opened by its button or /model.
 export function ModelPicker({
   models,
   model,
+  label,
   open,
   onOpenChange,
   onPick,
 }: {
   models: ChatModel[];
   model: string;
+  label?: string;
   open: boolean;
   onOpenChange: (open: boolean) => void;
   onPick: (value: string) => void;
@@ -37,7 +43,7 @@ export function ModelPicker({
           className="text-muted-foreground hover:text-foreground hover:bg-foreground/[0.05] flex h-10 max-w-36 min-w-0 items-center gap-1 rounded-lg px-2 text-xs"
         >
           <span className="truncate">
-            {modelLabel(models, model) || "Model"}
+            {modelLabel(models, model, label) || "Model"}
           </span>
           <ChevronDown className="h-3 w-3 shrink-0" />
         </button>

package/components/Chat/PausedBanner.tsx

@@ -0,0 +1,54 @@
+"use client";
+
+import { Pause } from "lucide-react";
+import { toast } from "sonner";
+import { useSessionsQuery } from "@/data/sessions";
+import { useResumeSession } from "@/data/sessions/shelf";
+import { pauseSubtitle } from "@/lib/sidebar/paused";
+import { Button } from "@/components/ui/button";
+
+// Above the composer while the session is paused: when it resumes, and a
+// button to resume it now. What is sent meanwhile waits and goes with it.
+export function PausedBanner({ sessionId }: { sessionId: string }) {
+  const { data } = useSessionsQuery();
+  const resume = useResumeSession();
+  const session = data?.sessions.find((s) => s.id === sessionId);
+  const state = session?.pause_state;
+  if (!session || !state) return null;
+  const until = session.paused_until
+    ? Date.parse(`${session.paused_until.replace(" ", "T")}Z`)
+    : null;
+  return (
+    <section
+      aria-label="Paused"
+      className="bg-card popover-surface mb-2 flex min-h-11 items-center gap-2 rounded-2xl px-3 py-1.5"
+    >
+      <Pause
+        aria-hidden
+        className="h-4 w-4 shrink-0 text-amber-600 dark:text-amber-400"
+      />
+      <p className="min-w-0 flex-1 text-sm">
+        {pauseSubtitle({ state, until })}
+        <span className="text-muted-foreground block text-xs">
+          Messages you send now are held and delivered together when it resumes.
+        </span>
+      </p>
+      {(state === "paused" || state === "pausing") && (
+        <Button
+          size="sm"
+          variant="secondary"
+          className="min-h-11 shrink-0"
+          disabled={resume.isPending}
+          onClick={() =>
+            resume.mutate(
+              { id: sessionId },
+              { onError: (e) => toast.error(e.message) }
+            )
+          }
+        >
+          {state === "paused" ? "Resume now" : "Keep running"}
+        </Button>
+      )}
+    </section>
+  );
+}

package/components/Chat/composer/ComposerBody.tsx

@@ -51,6 +51,7 @@ export interface ComposerProps {
   refreshingCommands?: boolean;
   models?: ChatModel[];
   model?: string;
+  modelLabel?: string;
   onSetModel?: (model: string) => void;
   access?: ChatAccess;
   onSetAccess?: (access: ChatAccess) => void;
@@ -88,6 +89,7 @@ export function ComposerBody({
   refreshingCommands = false,
   models = [],
   model = "",
+  modelLabel,
   onSetModel,
   access,
   onSetAccess,
@@ -329,6 +331,7 @@ export function ComposerBody({
           onSetAccess={onSetAccess}
           models={models}
           model={model}
+          modelLabel={modelLabel}
           onSetModel={onSetModel}
           modelOpen={modelOpen}
           onModelOpenChange={setModelOpen}

package/components/Chat/composer/Toolbar.tsx

@@ -31,6 +31,7 @@ export function Toolbar({
   onSetAccess,
   models,
   model,
+  modelLabel,
   onSetModel,
   modelOpen,
   onModelOpenChange,
@@ -51,6 +52,7 @@ export function Toolbar({
   onSetAccess?: (access: ChatAccess) => void;
   models: ChatModel[];
   model: string;
+  modelLabel?: string;
   onSetModel?: (model: string) => void;
   modelOpen: boolean;
   onModelOpenChange: (open: boolean) => void;
@@ -135,6 +137,7 @@ export function Toolbar({
         <ModelPicker
           models={models}
           model={model}
+          label={modelLabel}
           open={modelOpen}
           onOpenChange={onModelOpenChange}
           onPick={onSetModel}

package/components/Draft/DraftChips.tsx

@@ -6,6 +6,7 @@ import {
   Cpu,
   FolderGit2,
   GitBranch,
+  Flag,
   GitPullRequest,
   Monitor,
   SquareTerminal,
@@ -21,6 +22,12 @@ import { useProjectMachinesQuery } from "@/data/projects";
 import { modelChoices, useModelsQuery } from "@/data/models";
 import type { AgentProbe } from "@/lib/agents/probe";
 import { ChipHeading, ChipItem, ChipMenu, ChipToggle } from "./Chip";
+import {
+  DEFAULT_PRIORITY,
+  PRIORITIES,
+  PRIORITY_HINT,
+  PRIORITY_LABEL,
+} from "@/lib/tasks/schedule-types";
 
 // What stands between an agent and its first prompt, if anything.
 export function agentBlocker(probe?: AgentProbe): string | null {
@@ -260,6 +267,24 @@ export function DraftChips({
           ))}
         </ChipMenu>
       )}
+      {project && draft.openPr && (
+        <ChipMenu
+          icon={Flag}
+          name="Priority"
+          label={PRIORITY_LABEL[draft.taskPriority ?? DEFAULT_PRIORITY]}
+        >
+          {PRIORITIES.map((p) => (
+            <ChipItem
+              key={p}
+              checked={p === (draft.taskPriority ?? DEFAULT_PRIORITY)}
+              onSelect={() => onChange({ taskPriority: p })}
+              hint={PRIORITY_HINT[p]}
+            >
+              {PRIORITY_LABEL[p]}
+            </ChipItem>
+          ))}
+        </ChipMenu>
+      )}
       {project && draft.openPr && (
         <ChipToggle
           icon={SquareTerminal}

package/components/Draft/DraftPanel.tsx

@@ -66,6 +66,7 @@ export function DraftPanel({
           projectId: project.id,
           prompt: text,
           model: draft.taskModel ?? undefined,
+          priority: draft.taskPriority,
           baseBranch: draft.baseBranch ?? undefined,
           hostId: draft.hostId !== project.host_id ? draft.hostId : undefined,
           view: draft.terminal ? "terminal" : undefined,

package/components/Recipes/format.ts

@@ -1,29 +1,26 @@
+import type { Tone } from "@/lib/config/client-config-types";
+import {
+  RUN_STATUS_LABELS,
+  RUN_TRIGGER_LABELS,
+} from "@/lib/recipes/status-labels";
 import type { RecipeRun, RunStatus } from "@/lib/recipes/types";
 
-export const STATUS_LABEL: Record<RunStatus, string> = {
-  queued: "Queued",
-  starting: "Starting",
-  running: "Running",
-  succeeded: "Succeeded",
-  failed: "Failed",
-  blocked: "Needs you",
-  timed_out: "Timed out",
-  cancelled: "Cancelled",
-  skipped: "Skipped",
-};
+export const STATUS_LABEL = Object.fromEntries(
+  Object.entries(RUN_STATUS_LABELS).map(([k, v]) => [k, v.label])
+) as Record<RunStatus, string>;
 
-export const STATUS_TONE: Record<RunStatus, string> = {
-  queued: "bg-foreground/10 text-muted-foreground",
-  starting: "bg-primary/15 text-primary",
-  running: "bg-primary/15 text-primary",
-  succeeded: "bg-emerald-500/15 text-emerald-700 dark:text-emerald-300",
-  failed: "bg-destructive/15 text-destructive",
-  blocked: "bg-amber-500/15 text-amber-700 dark:text-amber-300",
-  timed_out: "bg-destructive/15 text-destructive",
-  cancelled: "bg-foreground/10 text-muted-foreground",
-  skipped: "bg-amber-500/15 text-amber-700 dark:text-amber-300",
+const TONE_CHIP: Record<Tone, string> = {
+  muted: "bg-foreground/10 text-muted-foreground",
+  warning: "bg-amber-500/15 text-amber-700 dark:text-amber-300",
+  primary: "bg-primary/15 text-primary",
+  destructive: "bg-destructive/15 text-destructive",
+  success: "bg-emerald-500/15 text-emerald-700 dark:text-emerald-300",
 };
 
+export const STATUS_TONE = Object.fromEntries(
+  Object.entries(RUN_STATUS_LABELS).map(([k, v]) => [k, TONE_CHIP[v.tone]])
+) as Record<RunStatus, string>;
+
 // SQLite's datetime('now') is UTC without a zone marker.
 export const sqlMs = (t: string | null) =>
   t ? Date.parse(`${t.replace(" ", "T")}Z`) : 0;
@@ -39,13 +36,5 @@ export function duration(ms: number | null): string {
 export const money = (n: number | null) =>
   n == null ? "" : `$${n < 10 ? n.toFixed(2) : n.toFixed(0)}`;
 
-const TRIGGER_LABEL = {
-  manual: "by hand",
-  tool: "by the orchestrator",
-  cli: "by an agent",
-  timer: "on its timer",
-  "catch-up": "on its timer, late",
-} as const;
-
 export const triggerLabel = (r: Pick<RecipeRun, "trigger">) =>
-  TRIGGER_LABEL[r.trigger];
+  RUN_TRIGGER_LABELS[r.trigger];