@saadnvd1/agent-os 0.3.477 → 0.3.481

package/README.md

@@ -745,6 +745,22 @@ next minute until the brake lifts or a newer run is due (Run now obeys them
 too, once). A schedule whose project has moved to another workspace fails
 until it's edited. Removing a schedule keeps its history.
 
+**One-off schedules.** Pick **Once** in the form (a date and time in the
+schedule's zone), or `aos schedule add --at "tomorrow 10am" ...` (an ISO time,
+`in 2h`, a weekday; America/Chicago unless `--tz`). It works with every kind,
+runs once and then turns itself off; the run stays in its history, marked
+done, and the schedule moves to the **Done** group. Upcoming one-offs are
+listed first with their run time, how far off it is and who made it (you or an
+orchestrator), each with Run now, Edit and Cancel; the count shows in the
+sidebar menu and the orchestrator's header. The same claim-in-SQLite rule
+applies, so it never runs twice, and one AgentOS missed while off runs when it
+returns, marked **caught up**. Pause holds a one-off until you resume rather
+than skipping it, and the brakes apply as for any run. A past time is refused.
+Run now uses up its only run; edit it to a new time to run it again. An
+orchestrator makes its own with `remind_me`: at least ten minutes ahead, 20
+pending at most, in its own workspace, and it arrives as a scheduled prompt,
+never an approval.
+
 Task and session schedules run at most hourly, message schedules at most
 every 10 minutes and skip a run (`still working`) while their session is
 still busy, mid-turn or holding a queued message. A task schedule waits
@@ -773,6 +789,15 @@ minutes, one message goes to your phone and to each workspace orchestrator,
 naming the top sessions and their heavy commands; the next one waits until
 it has been green for ten minutes. `AGENTOS_LOAD=off` turns it all off.
 
+### Tmux cleanup
+
+Deleting, finishing, dropping or marking a session done ends its tmux session
+and every process its panes started, on the machine it runs on. At start,
+AgentOS also ends tmux sessions it created (its `<agent>-<uuid>` and
+`aos-chat-<uuid>` names, or the `AGENTOS_SESSION_ID` it sets at launch) whose
+session no longer exists, and logs each as `[tmux-sweep]`. Sessions it didn't
+create are never touched. The sweep runs only in production mode (a dev or test instance shares the tmux server but not the database); `AGENTOS_TMUX_SWEEP=off` skips it.
+
 ### Phone notifications
 
 Two things reach your phone: a schedule run that failed, and whatever an
@@ -984,7 +1009,7 @@ it may do on its own, and the lines that always come back to you as asks.
   workspace, or the project already at that path moves in from no workspace;
   folders that hold secrets and projects of another workspace are refused),
   `note`,
-  `rule_add`, `rule_remove`, `review`, `sign_off`, `arm`, `disarm` and `ask_saad`. All are served in-process to its chat, refuse
+  `rule_add`, `rule_remove`, `review`, `sign_off`, `arm`, `disarm`, `remind_me`, `reminders`, `cancel_reminder` and `ask_saad`. All are served in-process to its chat, refuse
   any target outside its workspace, and validate their arguments. The one
   exception is other orchestrators: `orchestrators` lists every workspace and
   whether it has one, and `message_orchestrator` messages another workspace's

package/app/api/schedules/route.ts

@@ -28,6 +28,7 @@ export async function POST(request: NextRequest) {
             from: body.from ? String(body.from) : null,
             every: body.every,
             cron: body.cron,
+            at: body.at,
             prompt: String(body.prompt ?? ""),
             name: body.name,
             timezone: body.timezone,

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

@@ -0,0 +1,66 @@
+import { randomUUID } from "crypto";
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// What deleting a session ends: tmux sessions by name, and the chat worker.
+const ended = vi.hoisted(() => [] as { host: unknown; name: unknown }[]);
+const stopped = vi.hoisted(() => [] as string[]);
+vi.mock("@/lib/tmux/end", () => ({
+  endTmuxSession: async (host: unknown, name: unknown) => {
+    ended.push({ host, name });
+  },
+}));
+vi.mock("@/lib/chat/runner", async (original) => ({
+  ...(await original<typeof import("@/lib/chat/runner")>()),
+  stopChat: (id: string) => stopped.push(id),
+}));
+vi.mock("@/lib/chat/worker/client", async (original) => ({
+  ...(await original<typeof import("@/lib/chat/worker/client")>()),
+  waitForExit: async () => {},
+}));
+
+const { DELETE } = await import("@/app/api/sessions/[id]/route");
+const { db } = await import("@/lib/db");
+
+const remove = (id: string) =>
+  DELETE(new NextRequest("http://x", { method: "DELETE" }), {
+    params: Promise.resolve({ id }),
+  });
+const exists = (id: string) =>
+  !!db.prepare(`SELECT 1 FROM sessions WHERE id = ?`).get(id);
+function add(fields: { tmux_name: string; host_id?: string }) {
+  const id = randomUUID();
+  db.prepare(
+    `INSERT INTO sessions (id, name, tmux_name, working_directory, host_id)
+     VALUES (?, 's', ?, '/tmp', ?)`
+  ).run(id, fields.tmux_name, fields.host_id ?? "local");
+  return id;
+}
+
+beforeEach(() => {
+  ended.length = 0;
+  stopped.length = 0;
+});
+
+describe("DELETE /api/sessions/[id]", () => {
+  it("ends the session's own tmux session, not just its row", async () => {
+    const id = add({ tmux_name: "claude-keepme" });
+    const res = await remove(id);
+    expect(res.status).toBe(200);
+    expect(exists(id)).toBe(false);
+    expect(ended).toEqual([{ host: "local", name: "claude-keepme" }]);
+    expect(stopped).toEqual([id]);
+  });
+
+  it("ends it on the machine the session runs on", async () => {
+    const id = add({ tmux_name: "claude-far", host_id: "host-1" });
+    await remove(id);
+    expect(ended).toEqual([{ host: "host-1", name: "claude-far" }]);
+  });
+
+  it("ends nothing for a session that doesn't exist", async () => {
+    const res = await remove(randomUUID());
+    expect(res.status).toBe(404);
+    expect(ended).toEqual([]);
+  });
+});

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

@@ -9,8 +9,9 @@ import {
 import { releasePort } from "@/lib/ports";
 import { dropSessionDatabase } from "@/lib/project-config/database";
 import { killWorker } from "@/lib/orchestration";
-import { hostExec, hostExecFile } from "@/lib/hosts";
-import { shellQuote } from "@/lib/hosts/ssh";
+import { endSessionAgent } from "@/lib/sessions/end";
+import { endTmuxSession } from "@/lib/tmux/end";
+import { hostExecFile } from "@/lib/hosts";
 import { supportsChat } from "@/lib/chat/capabilities";
 import { stopChat } from "@/lib/chat/runner";
 import { statusDetector } from "@/lib/status-detector";
@@ -124,10 +125,7 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
       }
       if (body.view === "terminal") stopChat(id);
       if (body.view === "chat" && existing.tmux_name) {
-        await hostExec(
-          existing.host_id,
-          `tmux kill-session -t ${shellQuote(`=${existing.tmux_name}`)} 2>/dev/null || true`
-        ).catch(() => {});
+        await endTmuxSession(existing.host_id, existing.tmux_name);
       }
       updates.push("view = ?");
       values.push(body.view);
@@ -276,7 +274,11 @@ export async function DELETE(request: NextRequest, { params }: RouteParams) {
     void dropSessionDatabase(id);
 
     // Delete from database immediately for instant UI feedback
-    stopChat(id);
+    // The agent's tmux and processes go on in the background; the worktree
+    // waits for them so nothing is still writing in it.
+    const agentEnded = endSessionAgent(existing).catch((error) =>
+      console.error(`Ending ${id}'s agent failed:`, error)
+    );
     deleteItems(id);
     clearQueue(id);
     queries.deleteSession(db).run(id);
@@ -285,6 +287,7 @@ export async function DELETE(request: NextRequest, { params }: RouteParams) {
     if (existing.worktree_path && isAgentOSWorktree(existing.worktree_path)) {
       const worktreePath = existing.worktree_path; // Capture for closure
       runInBackground(async () => {
+        await agentEnded;
         const gitCommonDir = await mainCheckoutOf(worktreePath);
 
         if (gitCommonDir) {

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

@@ -323,6 +323,8 @@ export async function POST(
         newTmuxSession,
         "-c",
         cwdExpanded,
+        "-e",
+        `AGENTOS_SESSION_ID=${newId}`,
         claudeCmd,
       ]);
       console.log(`[summarize] Tmux session created: ${newTmuxSession}`);

package/app/api/tmux/kill-all/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from "next/server";
 import { getDb, queries, type Session } from "@/lib/db";
 import { getManagedSessionPattern } from "@/lib/providers/registry";
 import { tmux } from "@/lib/tmux/exec";
+import { endTmuxSession } from "@/lib/tmux/end";
 
 // POST /api/tmux/kill-all - Kill all AgentOS tmux sessions and remove from database
 export async function POST() {
@@ -25,7 +26,7 @@ export async function POST() {
     const killed: string[] = [];
     for (const session of tmuxSessions) {
       try {
-        await tmux(["kill-session", "-t", `=${session}`], 5000);
+        await endTmuxSession(null, session);
         killed.push(session);
       } catch {
         // Session might already be dead, continue

package/components/Orchestrator/OrchestratorBar.tsx

@@ -8,6 +8,8 @@ import { usePauseOrchestrator } from "@/data/orchestrators";
 import { useOrchestratorHeader } from "@/hooks/useOrchestratorHeader";
 import { headerParts } from "@/lib/orchestrator/header-line";
 import { cn } from "@/lib/utils";
+import { useSchedulesGlance } from "@/components/SessionList/useSchedulesGlance";
+import { schedulesUiActions } from "@/stores/schedulesUi";
 import { NO_PASSKEYS_HERE, passkeysHere } from "@/data/presence";
 import { AsksList } from "./AsksList";
 
@@ -21,6 +23,7 @@ export const OrchestratorBar = memo(function OrchestratorBar({
 }) {
   const { overview, counts } = useOrchestratorHeader(workspaceId);
   const pause = usePauseOrchestrator(workspaceId);
+  const { upcomingText } = useSchedulesGlance(workspaceId);
   const [open, setOpen] = useState(true);
   const canProve = useSyncExternalStore(
     () => () => {},
@@ -73,6 +76,15 @@ export const OrchestratorBar = memo(function OrchestratorBar({
           {counts.paused ? "Resume" : "Pause"}
         </Button>
       </div>
+      {upcomingText && (
+        <button
+          type="button"
+          onClick={() => schedulesUiActions.open(workspaceId)}
+          className="text-muted-foreground hover:text-foreground flex min-h-11 w-full items-center px-1 text-left text-xs md:min-h-8"
+        >
+          {upcomingText}
+        </button>
+      )}
       {counts.paused && (
         <p className="text-muted-foreground px-1 text-xs">
           Paused: events wait and it won&apos;t start, merge or message anything

package/components/Schedules/ScheduleForm.tsx

@@ -31,8 +31,10 @@ import {
   minGapMinutes,
   nextRuns,
   presetCron,
+  wall,
   type PresetKind,
 } from "@/lib/schedules/cron";
+import { parseWhen, relativeTime } from "@/lib/schedules/when";
 
 const KINDS: { value: ScheduleKind; label: string; hint: string }[] = [
   {
@@ -57,7 +59,10 @@ const KINDS: { value: ScheduleKind; label: string; hint: string }[] = [
   },
 ];
 
-const PRESETS: { value: PresetKind | "custom"; label: string }[] = [
+type Preset = PresetKind | "custom" | "once";
+
+const PRESETS: { value: Preset; label: string }[] = [
+  { value: "once", label: "Once" },
   { value: "every", label: "Every…" },
   { value: "hourly", label: "Hourly" },
   { value: "daily", label: "Daily" },
@@ -115,6 +120,17 @@ function Segmented<T extends string>({
   );
 }
 
+const pad = (n: number) => String(n).padStart(2, "0");
+
+// The date and time inputs' values for an instant, as the zone's wall clock.
+function wallParts(ms: number, tz: string) {
+  const w = wall(ms, tz);
+  return {
+    date: `${w.y}-${pad(w.m)}-${pad(w.d)}`,
+    time: `${pad(w.h)}:${pad(w.mi)}`,
+  };
+}
+
 const Field = ({
   label,
   children,
@@ -148,7 +164,8 @@ export function ScheduleForm({
   const update = useUpdateSchedule();
   const mutation = existing ? update : create;
 
-  const initialPreset = existing ? cronPreset(existing.cron) : null;
+  const initialPreset =
+    existing && existing.run_at == null ? cronPreset(existing.cron) : null;
   const [wsId, setWsId] = useState(
     existing?.workspace_id ?? workspaceId ?? workspaces[0]?.id ?? ""
   );
@@ -161,9 +178,24 @@ export function ScheduleForm({
   );
   const [projectId, setProjectId] = useState(existing?.project_id ?? "");
   const [prompt, setPrompt] = useState(existing?.prompt ?? "");
-  const [preset, setPreset] = useState<PresetKind | "custom">(
-    existing ? (initialPreset?.kind ?? "custom") : draft ? "every" : "weekdays"
+  const [preset, setPreset] = useState<Preset>(
+    existing?.run_at != null
+      ? "once"
+      : existing
+        ? (initialPreset?.kind ?? "custom")
+        : draft
+          ? "every"
+          : "weekdays"
+  );
+  // A new one-off starts an hour out.
+  const [initialAt] = useState(() =>
+    wallParts(
+      existing?.run_at ?? Date.now() + 3_600_000,
+      existing?.timezone ?? DEFAULT_TIMEZONE
+    )
   );
+  const [atDate, setAtDate] = useState(initialAt.date);
+  const [atTime, setAtTime] = useState(initialAt.time);
   const [every, setEvery] = useState(initialPreset?.every ?? 30);
   const [hour, setHour] = useState(initialPreset?.hour ?? 9);
   const [minute, setMinute] = useState(initialPreset?.minute ?? 0);
@@ -197,12 +229,14 @@ export function ScheduleForm({
     .sort((a, b) => a.name.localeCompare(b.name));
   const target = targets.find((s) => s.id === targetId)?.id ?? "";
 
-  const cron =
-    preset === "custom"
+  const once = preset === "once";
+  const cron = once
+    ? ""
+    : preset === "custom"
       ? custom.trim()
       : presetCron({ kind: preset, hour, minute, weekday, every });
   const tzOk = isTimezone(timezone);
-  const cronProblem = cronError(cron);
+  const cronProblem = once ? null : cronError(cron);
   // The preview counts from now, kept fresh while the form is open.
   const [openedAt, setOpenedAt] = useState(() => Date.now());
   useEffect(() => {
@@ -214,13 +248,32 @@ export function ScheduleForm({
     [cron, cronProblem, timezone, tzOk, openedAt]
   );
 
+  // The picked wall time in the zone, or null while it's incomplete.
+  const runAt = useMemo(() => {
+    if (!once || !tzOk || !atDate || !atTime) return null;
+    try {
+      return parseWhen(`${atDate}T${atTime}`, timezone);
+    } catch {
+      return null;
+    }
+  }, [once, tzOk, atDate, atTime, timezone]);
+  // Saving a done one-off at its old time can't reopen it; a new time must be ahead.
+  const atProblem =
+    once && tzOk
+      ? runAt === null
+        ? "Pick a date and time"
+        : runAt <= openedAt && runAt !== existing?.run_at
+          ? "That time has passed"
+          : null
+      : null;
+
   const submit = (e: React.FormEvent) => {
     e.preventDefault();
     const input = {
       workspaceId: workspace,
       projectId: project || null,
       name,
-      cron,
+      ...(once ? { at: runAt } : { cron }),
       timezone,
       prompt,
       kind,
@@ -242,10 +295,11 @@ export function ScheduleForm({
   const tooOften = useMemo(
     () =>
       minGap > 0 &&
+      !once &&
       !cronProblem &&
       tzOk &&
       minGapMinutes(cron, timezone, openedAt) < minGap,
-    [minGap, cron, cronProblem, timezone, tzOk, openedAt]
+    [minGap, once, cron, cronProblem, timezone, tzOk, openedAt]
   );
 
   const ready =
@@ -253,6 +307,7 @@ export function ScheduleForm({
     prompt.trim() &&
     workspace &&
     !cronProblem &&
+    !atProblem &&
     tzOk &&
     !tooOften &&
     (kind === "message" ? target : kind === "orchestrator" || project);
@@ -362,7 +417,24 @@ export function ScheduleForm({
             setPreset(v);
           }}
         />
-        {preset === "custom" ? (
+        {once ? (
+          <div className="flex flex-wrap gap-2">
+            <Input
+              type="date"
+              aria-label="Date"
+              value={atDate}
+              onChange={(e) => setAtDate(e.target.value)}
+              className="h-11 w-44 md:h-9"
+            />
+            <Input
+              type="time"
+              aria-label="Time"
+              value={atTime}
+              onChange={(e) => setAtTime(e.target.value)}
+              className="h-11 w-32 md:h-9"
+            />
+          </div>
+        ) : preset === "custom" ? (
           <Input
             aria-label="Cron expression"
             value={custom}
@@ -450,10 +522,20 @@ export function ScheduleForm({
           className="text-muted-foreground h-11 md:h-8 md:text-xs"
         />
         <div className="bg-primary/[0.06] rounded-lg px-3 py-2.5 text-sm">
-          {cronProblem || !tzOk ? (
+          {cronProblem || !tzOk || atProblem ? (
             <p className="text-destructive">
-              {cronProblem ?? `Unknown time zone "${timezone}"`}
+              {!tzOk
+                ? `Unknown time zone "${timezone}"`
+                : (cronProblem ?? atProblem)}
             </p>
+          ) : once && runAt !== null ? (
+            <>
+              <p className="font-medium">{formatRunTime(runAt, timezone)}</p>
+              <p className="text-muted-foreground mt-1 text-xs">
+                Runs once, {relativeTime(runAt, openedAt)}, then turns itself
+                off.
+              </p>
+            </>
           ) : (
             <>
               <p className="font-medium">{describeCron(cron)}</p>

package/components/Schedules/SchedulesPanel.tsx

@@ -25,6 +25,7 @@ import {
 } from "@/data/schedules";
 import type { ScheduleView } from "@/lib/schedules";
 import { formatRunTime } from "@/lib/schedules/cron";
+import { relativeTime } from "@/lib/schedules/when";
 import { schedulesUi, schedulesUiActions } from "@/stores/schedulesUi";
 import { ScheduleForm } from "./ScheduleForm";
 import { OutcomeChip, RunHistory } from "./RunHistory";
@@ -50,10 +51,14 @@ const where = (s: ScheduleView) =>
       : "";
 
 function NextRun({ s }: { s: ScheduleView }) {
+  if (s.done_at) return <>Done {formatRunTime(s.done_at, s.timezone)}</>;
   if (!s.enabled) return <>Off</>;
   if (s.paused) return <>Paused with the orchestrator</>;
   return s.nextRunAt ? (
-    <>Next {formatRunTime(s.nextRunAt, s.timezone)}</>
+    <>
+      {s.oneOff ? "Runs" : "Next"} {formatRunTime(s.nextRunAt, s.timezone)}
+      {s.oneOff && ` (${relativeTime(s.nextRunAt)})`}
+    </>
   ) : (
     <>No upcoming run</>
   );
@@ -98,15 +103,44 @@ function ScheduleRow({ s, onOpen }: { s: ScheduleView; onOpen: () => void }) {
           </span>
         </div>
         <p className="text-muted-foreground truncate text-xs">
-          {s.description} · <NextRun s={s} />
+          {s.oneOff ? (
+            <NextRun s={s} />
+          ) : (
+            <>
+              {s.description} · <NextRun s={s} />
+            </>
+          )}
+          {s.oneOff && ` · by ${s.createdBy.name}`}
         </p>
       </div>
       {s.lastRun && <OutcomeChip run={s.lastRun} />}
-      <EnableSwitch s={s} />
+      {!s.done_at && <EnableSwitch s={s} />}
     </div>
   );
 }
 
+function Group({
+  title,
+  rows,
+  onOpen,
+}: {
+  title: string;
+  rows: ScheduleView[];
+  onOpen: (id: string) => void;
+}) {
+  if (rows.length === 0) return null;
+  return (
+    <section className="space-y-2">
+      <h4 className="text-muted-foreground px-1 text-xs font-medium">
+        {title} · {rows.length}
+      </h4>
+      {rows.map((s) => (
+        <ScheduleRow key={s.id} s={s} onOpen={() => onOpen(s.id)} />
+      ))}
+    </section>
+  );
+}
+
 function Detail({
   id,
   onEdit,
@@ -134,11 +168,12 @@ function Detail({
       <div className="space-y-1">
         <div className="flex items-center gap-2">
           <h3 className="min-w-0 flex-1 truncate font-semibold">{s.name}</h3>
-          <EnableSwitch s={s} />
+          {!s.done_at && <EnableSwitch s={s} />}
         </div>
         <p className="text-muted-foreground text-sm">
           {KIND_LABEL[s.kind]}
           {where(s)} · {s.description}
+          {s.oneOff && ` · by ${s.createdBy.name}`}
         </p>
         <p className="text-muted-foreground text-xs">
           <NextRun s={s} /> · {s.timezone}
@@ -151,7 +186,7 @@ function Detail({
         <Button
           size="sm"
           className="h-11 md:h-8"
-          disabled={run.isPending}
+          disabled={run.isPending || !!s.done_at}
           onClick={() => run.mutate(s.id)}
         >
           <Play className="h-3.5 w-3.5" />
@@ -174,7 +209,7 @@ function Detail({
             disabled={archive.isPending}
             onClick={() => archive.mutate(s.id, { onSuccess: onGone })}
           >
-            Remove (keeps history)
+            {s.oneOff && !s.done_at ? "Cancel it" : "Remove (keeps history)"}
           </Button>
         ) : (
           <Button
@@ -184,7 +219,7 @@ function Detail({
             onClick={() => setConfirm(true)}
           >
             <Trash2 className="h-3.5 w-3.5" />
-            Remove
+            {s.oneOff && !s.done_at ? "Cancel" : "Remove"}
           </Button>
         )}
       </div>
@@ -300,13 +335,24 @@ export function SchedulesPanel() {
               </p>
             </div>
           )}
-          {schedules.map((s) => (
-            <ScheduleRow
-              key={s.id}
-              s={s}
-              onOpen={() => setView({ mode: "detail", id: s.id })}
-            />
-          ))}
+          {(() => {
+            const open = (id: string) => setView({ mode: "detail", id });
+            const upcoming = schedules
+              .filter((s) => s.oneOff && !s.done_at)
+              .sort((a, b) => (a.run_at ?? 0) - (b.run_at ?? 0));
+            const done = schedules.filter((s) => s.done_at);
+            return (
+              <>
+                <Group title="Upcoming" rows={upcoming} onOpen={open} />
+                <Group
+                  title="Recurring"
+                  rows={schedules.filter((s) => !s.oneOff)}
+                  onOpen={open}
+                />
+                <Group title="Done" rows={done} onOpen={open} />
+              </>
+            );
+          })()}
           {!isPending && <PhoneLine />}
         </div>
       )}

package/components/SessionList/OrchestratorPinRow.tsx

@@ -12,6 +12,7 @@ import { orchestratorOpenActions } from "@/stores/orchestratorOpen";
 import { useRowContext } from "./RowContext";
 import { SessionRowMenu } from "./SessionRowMenu";
 import { RowRename, UnreadDot } from "./RowParts";
+import { QuickChangeRow } from "./QuickChangeRow";
 
 // A workspace's orchestrator, pinned above its sessions and titled with the
 // workspace's name: what it's doing and how many asks wait on you, on a line
@@ -126,12 +127,17 @@ export const OrchestratorPinRow = memo(function OrchestratorPinRow({
   );
 
   return (
-    <CM.ContextMenu>
-      <CM.ContextMenuTrigger asChild>{content}</CM.ContextMenuTrigger>
-      <CM.ContextMenuContent className="w-56">
-        {menu("context")}
-      </CM.ContextMenuContent>
-    </CM.ContextMenu>
+    <>
+      <CM.ContextMenu>
+        <CM.ContextMenuTrigger asChild>{content}</CM.ContextMenuTrigger>
+        <CM.ContextMenuContent className="w-56">
+          {menu("context")}
+        </CM.ContextMenuContent>
+      </CM.ContextMenu>
+      {row.quick?.map((q) => (
+        <QuickChangeRow key={q.session.id} row={q} />
+      ))}
+    </>
   );
 }, sameProps);
 

package/components/SessionList/QuickChangeRow.tsx

@@ -0,0 +1,58 @@
+"use client";
+
+import { GitPullRequest } from "lucide-react";
+import type { SidebarRow } from "@/lib/sidebar/shelves";
+import { TASK_STATE } from "@/components/Tasks/task-state-labels";
+import { cn } from "@/lib/utils";
+
+// One of an orchestrator's quick changes, under it: its name, its PR and
+// where CI stands. It has no agent to open, so the row opens its PR.
+export function QuickChangeRow({ row }: { row: SidebarRow }) {
+  const { session } = row;
+  const pr = session.pr_number && session.pr_url ? session.pr_url : null;
+  const state = row.task ? TASK_STATE[row.task] : null;
+  const label = !session.pr_number
+    ? "Editing, no PR yet"
+    : `PR #${session.pr_number}${state ? ` · ${state.label}` : ""}`;
+  const body = (
+    <>
+      <GitPullRequest
+        aria-hidden
+        className={cn(
+          "h-3.5 w-3.5 shrink-0",
+          state?.tone ?? "text-muted-foreground"
+        )}
+      />
+      <span className="flex min-w-0 flex-1 flex-col leading-tight">
+        <span className="text-foreground truncate text-[13px]">
+          {session.name}
+        </span>
+        <span
+          className={cn(
+            "mt-0.5 truncate text-xs",
+            session.pr_number && state ? state.tone : "text-muted-foreground"
+          )}
+        >
+          {label}
+        </span>
+      </span>
+    </>
+  );
+  const frame =
+    "ml-5 flex min-h-11 items-center gap-2 rounded-md px-2.5 py-1 md:min-h-9";
+  return pr ? (
+    <a
+      href={pr}
+      target="_blank"
+      rel="noreferrer"
+      title={`Quick change: ${session.name}\n${label}`}
+      className={cn(frame, "hover:bg-muted/60 transition-colors")}
+    >
+      {body}
+    </a>
+  ) : (
+    <div title={`Quick change: ${session.name}\n${label}`} className={frame}>
+      {body}
+    </div>
+  );
+}