@saadnvd1/agent-os 0.3.571 → 0.3.573

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/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/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,
@@ -716,6 +717,7 @@ export function ChatPanel({
             setInsert({ text: quoteMarkdown(text), at: Date.now() })
           }
         />
+        <PausedBanner sessionId={sessionId} />
         <Queue
           queue={queue}
           running={running}

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/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/SessionList/QueuedRow.tsx

@@ -1,12 +1,13 @@
 "use client";
 
 import { Fragment } from "react";
-import { ArrowDown, ArrowUp, Play, Trash2 } from "lucide-react";
+import { ArrowDown, ArrowUp, Flag, Play, Trash2 } from "lucide-react";
 import { toast } from "sonner";
 import * as DM from "@/components/ui/dropdown-menu";
 import * as CM from "@/components/ui/context-menu";
-import { useQueueAction, type QueueAction } from "@/data/tasks";
+import { useQueueAction, useSetPriority, type QueueAction } from "@/data/tasks";
 import {
+  priorityMenu,
   queueMenu,
   queuedSubtitle,
   type QueuedRow as Row,
@@ -22,6 +23,18 @@ const SEPARATOR = {
   context: CM.ContextMenuSeparator,
 };
 const icon = "mr-2 h-3.5 w-3.5";
+const SUB = {
+  dropdown: {
+    Sub: DM.DropdownMenuSub,
+    Trigger: DM.DropdownMenuSubTrigger,
+    Content: DM.DropdownMenuSubContent,
+  },
+  context: {
+    Sub: CM.ContextMenuSub,
+    Trigger: CM.ContextMenuSubTrigger,
+    Content: CM.ContextMenuSubContent,
+  },
+};
 const ICONS = { start: Play, up: ArrowUp, down: ArrowDown, remove: Trash2 };
 
 const DONE: Record<QueueAction, string> = {
@@ -55,16 +68,47 @@ export function QueuedRow({ row }: { row: Row }) {
     );
   const failed = item.status === "failed";
   const busy = action.isPending;
+  const setPriority = useSetPriority();
+  const priorities = priorityMenu(item);
 
   const items = queueMenu(row);
   const menu = items.length
     ? (kind: RowMenuKind) => {
         const Item = ITEM[kind];
         const Separator = SEPARATOR[kind];
+        const { Sub, Trigger, Content } = SUB[kind];
         return items.map(({ action: a, label, disabled }) => {
           const Icon = ICONS[a];
           return (
             <Fragment key={a}>
+              {a === "remove" && priorities.length > 0 && (
+                <Sub>
+                  <Trigger>
+                    <Flag className={icon} />
+                    Priority
+                  </Trigger>
+                  <Content>
+                    {priorities.map((p) => (
+                      <Item
+                        key={p.priority}
+                        onClick={() =>
+                          setPriority.mutate(
+                            { id: item.id, priority: p.priority },
+                            { onError: (e) => toast.error(e.message) }
+                          )
+                        }
+                      >
+                        {p.label}
+                        {p.current && (
+                          <span className="text-muted-foreground ml-3 text-xs">
+                            current
+                          </span>
+                        )}
+                      </Item>
+                    ))}
+                  </Content>
+                </Sub>
+              )}
               {a === "remove" && items.length > 1 && <Separator />}
               <Item
                 disabled={disabled || busy}

package/components/SessionList/RowSubtitle.tsx

@@ -9,6 +9,7 @@ import { headerParts } from "@/lib/orchestrator/header-line";
 import { cn } from "@/lib/utils";
 import { usageLabel, useSessionUsage } from "@/data/load";
 import { useRowContext } from "./RowContext";
+import { pauseSubtitle } from "@/lib/sidebar/paused";
 
 const ATTENTION = (part: string) => part === "paused" || /\basks?$/.test(part);
 
@@ -56,9 +57,21 @@ export function RowSubtitle({
   }
   const project = ctx.projectNames.get(session.project_id ?? "");
   const group = rowGroup(session);
+  const pause = session.pause_state;
   return (
     <span className="flex min-w-0 items-center gap-1.5">
-      <LiveLine {...live} />
+      {pause ? (
+        <span className="min-w-0 truncate text-xs text-amber-600 dark:text-amber-400">
+          {pauseSubtitle({
+            state: pause,
+            until: session.paused_until
+              ? Date.parse(`${session.paused_until.replace(" ", "T")}Z`)
+              : null,
+          })}
+        </span>
+      ) : (
+        <LiveLine {...live} />
+      )}
       {group && (
         <span
           className="text-muted-foreground/70 hidden min-w-0 shrink items-center gap-1 truncate text-xs @[14rem]:flex"
@@ -72,9 +85,14 @@ export function RowSubtitle({
           <span className="truncate">{group.text}</span>
         </span>
       )}
-      {(project || detail || usage) && (
+      {(project || detail || usage || session.placed_note) && (
         <span className="text-muted-foreground/70 min-w-0 truncate text-xs">
-          {[usage && usageLabel(usage), detail?.slice(0, 200), project]
+          {[
+            usage && usageLabel(usage),
+            detail?.slice(0, 200),
+            session.placed_note,
+            project,
+          ]
             .filter(Boolean)
             .join(" · ")}
         </span>

package/components/SessionList/SessionRowMenu.tsx

@@ -17,6 +17,7 @@ import {
   Loader2,
   Pencil,
   Pin,
+  Pause,
   Play,
   Repeat,
   ChefHat,
@@ -35,7 +36,13 @@ import { rowGroup } from "@/lib/recipes/chip";
 import { finishActions } from "@/lib/sidebar/row-actions";
 import { useArchiveAction, useDoneAction } from "./useDoneAction";
 import { useShelfActions } from "./useShelfActions";
-import { SNOOZE_PRESETS, snoozePreset, wakeLabel } from "@/lib/sidebar/snooze";
+import {
+  PAUSE_PRESETS,
+  SNOOZE_PRESETS,
+  pauseUntil,
+  snoozePreset,
+  wakeLabel,
+} from "@/lib/sidebar/snooze";
 import type { SidebarRow } from "@/lib/sidebar/shelves";
 import { useRowContext } from "./RowContext";
 import { MoveMenuItems } from "@/components/Tasks/MoveMenuItems";
@@ -399,6 +406,47 @@ export function SessionRowMenu({
               </Sub>
             )
           )}
+          {session.task_status || session.view === "chat" ? (
+            session.pause_state === "paused" ||
+            session.pause_state === "pausing" ? (
+              <Item onClick={() => shelf.resume(session)}>
+                <Play className={icon} />
+                {session.pause_state === "paused"
+                  ? "Resume now"
+                  : "Keep running"}
+              </Item>
+            ) : session.pause_state ? null : (
+              <Sub>
+                <SubTrigger>
+                  <Pause className={icon} />
+                  Pause
+                </SubTrigger>
+                <SubContent>
+                  {PAUSE_PRESETS.map((p) => {
+                    const at = pauseUntil(p.key);
+                    return (
+                      <Item
+                        key={p.key}
+                        onClick={() => shelf.pause(session, p.key)}
+                      >
+                        {p.label}
+                        {at && (
+                          <span className="text-muted-foreground ml-3 text-xs">
+                            {wakeLabel(at.getTime())}
+                          </span>
+                        )}
+                      </Item>
+                    );
+                  })}
+                  <Item
+                    onClick={() => shelf.pause(session, "until-resumed", true)}
+                  >
+                    Pause now (interrupt its step)
+                  </Item>
+                </SubContent>
+              </Sub>
+            )
+          ) : null}
           {plain &&
             (row.settled ? (
               <Item onClick={() => shelf.reopen(session)}>