@saadnvd1/agent-os 0.3.570 → 0.3.572

package/lib/orchestrator/brief.ts

@@ -119,7 +119,7 @@ Reading:
 Acting:
 - \`${TOOL_NAMES.send}\` (session, message, scope_change?): message a session; it arrives as its next prompt. scope_change records it on the task's brief for its review.
 - \`${TOOL_NAMES.message_orchestrator}\` (workspace, message): message another workspace's orchestrator, the only thing you reach outside this workspace. Use it to hand over a bug or ask for something in its projects; it decides what to do there.
-- \`${TOOL_NAMES.start_task}\` (project, prompt, base?, name?, view?, after?, model?, plan, plan_only?, plan_reason): a task in its own worktree that ends in a PR. Write the prompt as a full brief; name it in 2-6 words, or it's named from the prompt. It runs as a chat; pass view terminal only when the job needs a TUI. Pass after (a task's id or name, or "any") to hold it until that task finishes, instead of remembering it in your notes. Over the workspace's running task limit it's queued too: the result says "Queued (position N)", it starts by itself, and you get an event when it does. Its models follow the role settings (it plans on the planning model, then implements on the implementation one); State plan and plan_reason for every task (see "Triage every job"). Pass model ("provider/model", or a map of role to one) only when Saad asks for one, or to put implementation on Opus when the work needs deep reasoning (say why in plan_reason or a note); another provider than anthropic only when Saad asks.
+- \`${TOOL_NAMES.start_task}\` (project, prompt, base?, name?, view?, after?, priority?, machine?, model?, plan, plan_only?, plan_reason): a task in its own worktree that ends in a PR. priority (urgent, blocking, normal, background) sets where it stands in the queue; machine mac pins work that needs this Mac. A busy or loaded machine holds a queued start and says why; don't retry it. Write the prompt as a full brief; name it in 2-6 words, or it's named from the prompt. It runs as a chat; pass view terminal only when the job needs a TUI. Pass after (a task's id or name, or "any") to hold it until that task finishes, instead of remembering it in your notes. Over the workspace's running task limit it's queued too: the result says "Queued (position N)", it starts by itself, and you get an event when it does. Its models follow the role settings (it plans on the planning model, then implements on the implementation one); State plan and plan_reason for every task (see "Triage every job"). Pass model ("provider/model", or a map of role to one) only when Saad asks for one, or to put implementation on Opus when the work needs deep reasoning (say why in plan_reason or a note); another provider than anthropic only when Saad asks.
 - \`${TOOL_NAMES.plan_pieces}\` (task, merge?, drop?): when a plan split into pieces (the plan-done event names them), list them; merge or drop edits the ones still waiting. A piece starts by itself once what it waits on has merged (or deployed); you don't start it.
 - \`${TOOL_NAMES.approve_plan}\` (task, message?): continue a plan_only task whose plan is ready; it implements on the implementation model, once. message amends the plan and is recorded on the task's brief as a scope change. Reject a plan with drop.
 - \`${TOOL_NAMES.set_task_model}\` (task, model, message?): move a paused task to another model and carry on in the same conversation and worktree; it keeps that model from then on. Only when Saad asks.
@@ -134,6 +134,9 @@ Acting:
 - \`${TOOL_NAMES.land}\` (id): merge a stack bottom-up through the gates.
 - \`${TOOL_NAMES.move}\` (task, machine): carry a running task to a linked machine (heavy test or build work), or back with machine "here". It keeps its branch, conversation and plan, and everything you do with a task works the same there: its events come to you, read, send, stop, done and drop reach it, and the gates judge its PR at its head. The machine it lands on holds it for you and can't merge it. It runs in the background; an event says when it lands. Refused while paused, and for a task waiting on Saad.
 - \`${TOOL_NAMES.drop}\` (task, reason): close a task's PR and remove its worktree (on whichever machine holds it).
+- \`${TOOL_NAMES.set_priority}\` (task, priority): re-rank a queued task (urgent, blocking, normal, background), or tag a running one. Urgent is a bug Saad hit; background starts last.
+- \`${TOOL_NAMES.pause_task}\` (task, for, now?, reason): pause a running task for 1h, 2h, until tomorrow 9 AM or until resumed. Its agent ends at the end of its step (now interrupts the step); its worktree and conversation stay and its slot frees for the next queued task. It resumes by itself, ahead of new arrivals, with what was held (CI and review notes, messages) in one prompt. Use it to make room for urgent work or to wait out a loaded machine. Refused for a task that is merging, moving, setting up or waiting on Saad.
+- \`${TOOL_NAMES.resume_task}\` (task): resume a pause you set now. A pause Saad set is his to lift.
 - \`${TOOL_NAMES.stop}\` (session): stop a session's agent, keeping its work.
 - \`${TOOL_NAMES.done}\` (session): finish a session whose work is complete. A task with an open PR merges through the same gates as sign_off first (refused naming the gate otherwise); then the agent stops, the worktree goes only if nothing in it would be lost, and the session lands on the sidebar's Done shelf (it is not archived). Not a rejection: use drop for that.
 - \`${TOOL_NAMES.archive}\` (session): put a session away, out of the sidebar, when Saad asks. Nothing is merged or cleaned up; refused while it works or has an open PR.

package/lib/orchestrator/digest.ts

@@ -56,6 +56,9 @@ interface TaskRow {
   pr_status: string | null;
   view: string;
   armed_at: string | null;
+  pause_state: string | null;
+  paused_until: string | null;
+  placed_note: string | null;
 }
 
 export interface CheckRow {
@@ -162,7 +165,7 @@ function tasksSection(
   const tasks = db
     .prepare(
       `SELECT s.id, s.name, p.name AS project, s.pr_number, s.pr_status, s.view,
-         s.merge_armed_at AS armed_at
+         s.merge_armed_at AS armed_at, s.pause_state, s.paused_until, s.placed_note
        FROM sessions s JOIN projects p ON p.id = s.project_id
        WHERE p.workspace_id = ? AND s.role IS NULL AND s.archived_at IS NULL
          AND s.task_status = 'running'
@@ -177,7 +180,11 @@ function tasksSection(
         : "no PR yet";
       const gates = gateState(checks.get(t.id), failures.get(t.id));
       const arm = t.armed_at ? " | armed to merge" : "";
-      return `- ${clip(t.name, 80)} (${t.project ?? "?"}, ${t.view}, id ${shortId(t.id)}): ${pr}${arm}${gates ? ` | ${gates}` : ""}`;
+      const paused = t.pause_state
+        ? ` | ${t.pause_state}${t.paused_until ? ` until ${t.paused_until} UTC` : t.pause_state === "paused" ? " until resumed" : ""}`
+        : "";
+      const placed = t.placed_note ? ` | ${t.placed_note}` : "";
+      return `- ${clip(t.name, 80)} (${t.project ?? "?"}, ${t.view}, id ${shortId(t.id)}): ${pr}${arm}${paused}${placed}${gates ? ` | ${gates}` : ""}`;
     }),
     empty: "- None.",
     more: "the sessions tool",
@@ -210,7 +217,7 @@ function externalSection(
 function queueSection(workspaceId: string): Section {
   const rows = db
     .prepare(
-      `SELECT q.id, q.name, q.prompt, q.status, q.after_task, q.after_any,
+      `SELECT q.id, q.name, q.prompt, q.status, q.after_task, q.after_any, q.priority, q.note,
          p.name AS project, a.name AS after_name
        FROM task_queue q JOIN projects p ON p.id = q.project_id
        LEFT JOIN sessions a ON a.id = q.after_task
@@ -226,6 +233,8 @@ function queueSection(workspaceId: string): Section {
     after_any: string | null;
     project: string;
     after_name: string | null;
+    priority: string;
+    note: string | null;
   }[];
   return {
     title: "Queued tasks, in line order",
@@ -236,7 +245,9 @@ function queueSection(workspaceId: string): Section {
           ? " | after any running task"
           : "";
       const status = r.status === "queued" ? "" : ` | ${r.status}`;
-      return `- ${i + 1}. ${clip(r.name ?? r.prompt, 80)} (${r.project}, id ${shortId(r.id)})${after}${status}`;
+      const priority = r.priority === "normal" ? "" : ` | ${r.priority}`;
+      const why = r.note ? ` | ${clip(r.note, 100)}` : "";
+      return `- ${i + 1}. ${clip(r.name ?? r.prompt, 80)} (${r.project}, id ${shortId(r.id)})${after}${priority}${status}${why}`;
     }),
     more: "the sessions tool",
   };

package/lib/orchestrator/serve.ts

@@ -12,6 +12,9 @@ import {
   stackStatus,
   startSession,
   startTask,
+  setTaskPriority,
+  pauseTask,
+  resumeTask,
   stop,
 } from "./act";
 import { readCards } from "./cards";
@@ -63,6 +66,9 @@ const ACTING = new Set<ToolName>([
   "move",
   "approve_plan",
   "plan_pieces",
+  "set_priority",
+  "pause_task",
+  "resume_task",
   "stop",
   "done",
   "review",
@@ -131,8 +137,20 @@ export async function runTool(
         plan: a.plan,
         planOnly: a.plan_only,
         planReason: a.plan_reason,
+        priority: a.priority,
+        machine: a.machine,
       });
     }
+    case "set_priority": {
+      const a = p(tool, raw);
+      return setTaskPriority(w, a.task, a.priority);
+    }
+    case "pause_task": {
+      const a = p(tool, raw);
+      return pauseTask(w, a.task, a.for, a.now ?? false, a.reason);
+    }
+    case "resume_task":
+      return resumeTask(w, p(tool, raw).task);
     case "approve_plan": {
       const a = p(tool, raw);
       const task = workspaceTask(w, a.task);

package/lib/orchestrator/tool-names.ts

@@ -29,6 +29,9 @@ export const TOOL_NAMES = {
   plan_pieces: name("plan_pieces"),
   drop: name("drop"),
   move: name("move"),
+  set_priority: name("set_priority"),
+  pause_task: name("pause_task"),
+  resume_task: name("resume_task"),
   stop: name("stop"),
   done: name("done"),
   archive: name("archive"),

package/lib/orchestrator/tool-schemas.ts

@@ -7,6 +7,7 @@ import { RAISED_KINDS } from "./asks";
 import { MAX_RULE_CHARS } from "./rules";
 import { PROJECT_NAME } from "../project-add/name";
 import { TASK_ROLES, type ModelRole } from "../models/roles";
+import { PRIORITIES } from "../tasks/schedule-types";
 
 const ref = (what: string) => z.string().trim().min(1).max(300).describe(what);
 const session = ref("Session name, project/name, or id from sessions");
@@ -115,6 +116,18 @@ export const TOOL_SHAPES = {
       .describe(
         'Queue it until this task finishes (id or name), or "any" for whichever running task finishes first'
       ),
+    priority: z
+      .enum(PRIORITIES)
+      .optional()
+      .describe(
+        "Where it stands in the queue: urgent (a bug Saad hit), blocking (something waits on it), normal (the default), background"
+      ),
+    machine: z
+      .enum(["mac", "any"])
+      .optional()
+      .describe(
+        'Where it may run: "mac" for work that needs this Mac (Xcode, a simulator); "any" if no machine need applies. Unset: the project\'s setting, else decided from its files'
+      ),
     model: modelOverride,
     plan: z
       .boolean()
@@ -233,6 +246,26 @@ export const TOOL_SHAPES = {
         'A linked machine\'s name (see Machines), or "here" to bring the task back'
       ),
   },
+  set_priority: {
+    task: ref("A queued or running task: name, project/name or id"),
+    priority: z.enum(PRIORITIES),
+  },
+  pause_task: {
+    task,
+    for: z
+      .enum(["1h", "2h", "tomorrow", "until_resumed"])
+      .describe(
+        "How long: 1h, 2h, tomorrow (9 AM, Saad's time) or until_resumed (until you or Saad resume it)"
+      ),
+    now: z
+      .boolean()
+      .optional()
+      .describe(
+        "Interrupt its step now. Default: let the step finish, then pause"
+      ),
+    reason: z.string().trim().min(1).max(300),
+  },
+  resume_task: { task },
   stop: { session },
   done: { session },
   archive: { session },

package/lib/orchestrator/tools.ts

@@ -62,7 +62,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   message_orchestrator:
     "Message another workspace's orchestrator, by workspace name; never any other session there. It arrives as its next prompt, marked as from you and fenced as untrusted.",
   start_task:
-    "Start a task: an agent in its own worktree that ends in a PR. It runs as a chat unless view is terminal (only for a job that needs a TUI). With after (a task's id or name, or \"any\"), or over the workspace's running task limit, it's queued and starts by itself; the result says Queued (position N). Its models follow the role settings (planning, implementation, review, scope); give model only when Saad asks for one. Always state plan (true or false) and plan_reason (plan_only true plans, then stops and waits for approve_plan instead of implementing): plan true for a big, unclear or cross-cutting job, false for a small, clear one whose steps you write into the prompt. Refused while a brake holds.",
+    'Start a task: an agent in its own worktree that ends in a PR. It runs as a chat unless view is terminal (only for a job that needs a TUI). priority (urgent, blocking, normal, background) says where it stands in the queue; machine "mac" pins work that needs this Mac. A busy machine holds a start and the result says why. With after (a task\'s id or name, or "any"), or over the workspace\'s running task limit, it\'s queued and starts by itself; the result says Queued (position N). Its models follow the role settings (planning, implementation, review, scope); give model only when Saad asks for one. Always state plan (true or false) and plan_reason (plan_only true plans, then stops and waits for approve_plan instead of implementing): plan true for a big, unclear or cross-cutting job, false for a small, clear one whose steps you write into the prompt. Refused while a brake holds.',
   set_task_model:
     'Resume a paused task on another model ("provider/model", or a map of role to one), keeping its conversation and worktree; it\'s told to carry on (or message). Refused mid-turn.',
   start_session:
@@ -81,6 +81,12 @@ const DESCRIPTIONS: Record<ToolName, string> = {
     "A task whose plan split into pieces: each piece, its repo, what it waits on and its state. With merge or drop (position numbers) it edits the pieces still waiting: a merged piece's slice goes to the piece before it, a dropped one is left out and anything waiting on it is held. It can't add pieces or change reasons.",
   drop: "Reject a task: close its PR and remove its worktree. A task still waiting in the queue is removed by its id. Logged with the reason.",
   move: 'Carry a running task to a linked machine, or back with "here": for heavy test or build work. It keeps its branch, conversation and plan; the gates, events, read, send, stop, done and drop work the same wherever it runs, and the machine it lands on can\'t merge it. Takes a few minutes and runs in the background; an event says when it lands. Refused while paused, for a task waiting on Saad (an escalation or open ask), and for card and stacked tasks.',
+  set_priority:
+    "Change the priority of a queued task (it re-ranks the line at once) or a running one (it only matters if it is paused and waits to resume). urgent starts first even on a busy machine; background starts last.",
+  pause_task:
+    "Pause a running task for a set time: its agent ends at the end of its current step (now true interrupts the step), its worktree and conversation stay, and it frees its slot so the next queued task can start. It resumes by itself at the time, ahead of new arrivals of the same priority, with whatever was held (CI and review notes, messages) in one continue prompt. Refused for a task that is merging, moving, setting up or waiting on Saad. Give a reason; it is shown with the pause.",
+  resume_task:
+    "Resume a task you paused (or the scheduler did) now. A pause Saad set is his to lift: this refuses and says so.",
   stop: "Stop a session's agent mid-turn, even while it's thinking, keeping its conversation, worktree and branch; your next message runs as its next turn.",
   done: "Finish a session whose work is complete: a task's open PR merges through the sign-off gates first (refused naming the failing gate), then its agent stops, its worktree is removed if nothing would be lost, and it lands on the sidebar's Done shelf; it no longer archives (use archive for that). Not a rejection.",
   archive:

package/lib/project-config/agentos.schema.json

@@ -151,6 +151,19 @@
       "required": ["start"],
       "additionalProperties": false
     },
+    "machine": {
+      "type": "object",
+      "properties": {
+        "needs": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": ["mac", "xcode", "simulator"]
+          }
+        }
+      },
+      "additionalProperties": false
+    },
     "database": {
       "type": "object",
       "properties": {

package/lib/project-config/schema.ts

@@ -69,6 +69,14 @@ const simulator = z.strictObject({
   device: z.string().min(1).optional(),
 });
 
+// What a project's tasks need from a machine (lib/tasks/placement.ts): `mac`,
+// `xcode`, `simulator`. A task whose needs a machine can't meet never starts
+// there; with none listed, repo files decide (an Xcode project implies all).
+export const MACHINE_NEEDS = ["mac", "xcode", "simulator"] as const;
+const machine = z.strictObject({
+  needs: z.array(z.enum(MACHINE_NEEDS)).optional(),
+});
+
 const database = z.strictObject({
   from: z.string().min(1),
   env: projectEnvName.optional(),
@@ -119,6 +127,7 @@ const shape = {
   notes: notes.optional(),
   browse: browse.optional(),
   simulator: simulator.optional(),
+  machine: machine.optional(),
   database: database.optional(),
   mcp: z.array(z.string().min(1)).optional(),
   model: z.string().min(1).optional(),

package/lib/recipes/status-labels.ts

@@ -0,0 +1,27 @@
+// How a recipe run's status and trigger read, for every client. Synced to the
+// native app, so it may only import synced files.
+import type { Tone } from "../config/client-config-types";
+import type { RunStatus, RunTriggerKind } from "./types";
+
+export const RUN_STATUS_LABELS: Record<
+  RunStatus,
+  { label: string; tone: Tone }
+> = {
+  queued: { label: "Queued", tone: "muted" },
+  starting: { label: "Starting", tone: "primary" },
+  running: { label: "Running", tone: "primary" },
+  succeeded: { label: "Succeeded", tone: "success" },
+  failed: { label: "Failed", tone: "destructive" },
+  blocked: { label: "Needs you", tone: "warning" },
+  timed_out: { label: "Timed out", tone: "destructive" },
+  cancelled: { label: "Cancelled", tone: "muted" },
+  skipped: { label: "Skipped", tone: "warning" },
+};
+
+export const RUN_TRIGGER_LABELS: Record<RunTriggerKind, string> = {
+  manual: "by hand",
+  tool: "by the orchestrator",
+  cli: "by an agent",
+  timer: "on its timer",
+  "catch-up": "on its timer, late",
+};

package/lib/sidebar/paused.ts

@@ -0,0 +1,13 @@
+import { wakeLabel } from "./snooze";
+
+// What a paused row says under its title.
+export function pauseSubtitle(
+  paused: { state: "pausing" | "paused" | "resuming"; until: number | null },
+  now: number = Date.now(),
+  timeZone?: string
+): string {
+  if (paused.state === "pausing") return "Pausing · finishing its step";
+  if (paused.state === "resuming") return "Resuming · waiting for a slot";
+  if (paused.until === null) return "Paused until you resume";
+  return `Paused · resumes ${wakeLabel(paused.until, now, timeZone)}`;
+}

package/lib/sidebar/queued.ts

@@ -1,4 +1,9 @@
 import type { QueuedTaskView } from "@/lib/tasks/queue";
+import {
+  PRIORITIES,
+  PRIORITY_LABEL,
+  type Priority,
+} from "@/lib/tasks/schedule-types";
 
 export interface QueuedRow {
   item: QueuedTaskView;
@@ -71,7 +76,35 @@ export function queuedSubtitle(item: QueuedTaskView): {
   // Why a start it tried is held: the orchestrator paused, a brake.
   if (item.note) return { lead: item.note, after: null };
   if (item.after) return { lead: "After", after: item.after };
-  return { lead: `#${item.position} in line`, after: null };
+  const priority =
+    item.priority === "normal" ? "" : ` · ${PRIORITY_LABEL[item.priority]}`;
+  return { lead: `#${item.rank} of ${item.of}${priority}`, after: null };
+}
+
+// The priority choices for a waiting task's menu, the current one marked.
+export function priorityMenu(
+  item: Pick<QueuedTaskView, "priority" | "status">
+): { priority: Priority; label: string; current: boolean }[] {
+  if (item.status !== "queued") return [];
+  return PRIORITIES.map((priority) => ({
+    priority,
+    label: PRIORITY_LABEL[priority],
+    current: priority === item.priority,
+  }));
+}
+
+export function priorityRequest(
+  id: string,
+  priority: Priority
+): { url: string; init: RequestInit } {
+  return {
+    url: `/api/tasks/${encodeURIComponent(id)}/priority`,
+    init: {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ priority }),
+    },
+  };
 }
 
 export type QueueMenuAction = "start" | "up" | "down" | "remove";

package/lib/sidebar/shelves.ts

@@ -67,6 +67,10 @@ export interface SidebarRow {
   wakesAt?: number;
   // A plain session in Done: marked by hand, or settled by itself.
   settled?: "manual" | "auto";
+  // Its agent is being stopped, is stopped, or is starting again
+  // (lib/tasks/pause): until is when it resumes by itself (ms), null: when
+  // someone resumes it.
+  paused?: { state: "pausing" | "paused" | "resuming"; until: number | null };
 }
 
 export interface Shelves {
@@ -234,6 +238,7 @@ export function recipeRunOpen(session: Pick<Session, "recipe_run">): boolean {
 function toRow(input: ShelfInput, session: Session, now: number): SidebarRow {
   const status = input.statuses[session.id];
   const wakesAt = snoozedUntil(session, now);
+  const pauseState = session.pause_state;
   return {
     session,
     status,
@@ -241,6 +246,12 @@ function toRow(input: ShelfInput, session: Session, now: number): SidebarRow {
     unread: !!status?.unread || wokeUnread(session, now),
     activeAt: activeMs(session, now),
     ...(wakesAt && { wakesAt }),
+    ...(pauseState && {
+      paused: {
+        state: pauseState,
+        until: session.paused_until ? ms(session.paused_until) : null,
+      },
+    }),
     working:
       status?.status === "running" ||
       (status?.background ?? 0) > 0 ||
@@ -305,6 +316,8 @@ export function buildShelves(input: ShelfInput): Shelves {
     if (pinned && current) shelves.orchestrators.push(row);
     else if (pinned && role !== "orchestrator") shelves.pinned.push(row);
     else if (row.need) shelves.needsYou.push(row);
+    // A stopped agent is not working, whatever its last status said.
+    else if (row.paused?.state === "paused") shelves.snoozed.push(row);
     else if (row.working) shelves.working.push(row);
     else if (row.wakesAt) shelves.snoozed.push(row);
     else if (row.task || row.session.task_status)
@@ -323,7 +336,12 @@ export function buildShelves(input: ShelfInput): Shelves {
   shelves.working.sort(newestFirst);
   shelves.inReview.sort(newestFirst);
   shelves.ongoing.sort((a, b) => b.activeAt - a.activeAt);
-  shelves.snoozed.sort((a, b) => a.wakesAt! - b.wakesAt!);
+  // By when each comes back; a pause with no end goes last.
+  const comesBack = (r: SidebarRow) =>
+    r.paused?.state === "paused"
+      ? (r.paused.until ?? Number.POSITIVE_INFINITY)
+      : r.wakesAt!;
+  shelves.snoozed.sort((a, b) => comesBack(a) - comesBack(b));
   shelves.done.sort((a, b) => doneAtMs(b) - doneAtMs(a));
   return shelves;
 }
@@ -390,6 +408,8 @@ export function sameRow(a: SidebarRow, b: SidebarRow): boolean {
     a.task === b.task &&
     a.activeAt === b.activeAt &&
     a.wakesAt === b.wakesAt &&
+    a.paused?.state === b.paused?.state &&
+    a.paused?.until === b.paused?.until &&
     a.settled === b.settled &&
     a.workers.length === b.workers.length &&
     a.workers.every((w, i) => sameRow(w, b.workers[i])) &&

package/lib/sidebar/snooze.ts

@@ -100,3 +100,29 @@ export function wakeLabel(
     return `${date.toLocaleDateString("en-US", { timeZone, weekday: "short" })} ${time}`;
   return `${date.toLocaleDateString("en-US", { timeZone, month: "short", day: "numeric" })}, ${time}`;
 }
+
+// How long a paused session stays paused: a set time, or until someone
+// resumes it. "Tomorrow" is the same 9am as Snooze's.
+export type PausePreset = "1h" | "2h" | "tomorrow" | "until-resumed";
+
+export const PAUSE_PRESETS: { key: PausePreset; label: string }[] = [
+  { key: "1h", label: "For 1 hour" },
+  { key: "2h", label: "For 2 hours" },
+  { key: "tomorrow", label: "Until tomorrow 9 AM" },
+  { key: "until-resumed", label: "Until I resume" },
+];
+
+// The instant a pause ends; null: until resumed.
+export function pauseUntil(
+  preset: PausePreset,
+  now: Date = new Date(),
+  timeZone: string = localZone()
+): Date | null {
+  if (preset === "1h") return new Date(now.getTime() + 3_600_000);
+  if (preset === "2h") return new Date(now.getTime() + 7_200_000);
+  if (preset === "tomorrow") return snoozePreset("tomorrow", now, timeZone);
+  return null;
+}
+
+export const isPausePreset = (v: unknown): v is PausePreset =>
+  PAUSE_PRESETS.some((p) => p.key === v);

package/lib/tasks/finish.ts

@@ -1,4 +1,5 @@
 import { db, type Session } from "../db";
+import { endPauseOnFinish } from "./pause-hold";
 import { isMirror, remoteTaskAction } from "./remote";
 import { deleteWorktree } from "../worktrees";
 import { settleWorktree, type MergedAs } from "../done/worktree";
@@ -154,6 +155,7 @@ export async function signOffTask(
     db.prepare(
       `UPDATE sessions SET task_status = 'merged', pr_status = 'merged' WHERE id = ?`
     ).run(id);
+    endPauseOnFinish(id);
     db.prepare(
       `UPDATE stack_items SET status = 'merged', error = NULL WHERE session_id = ?`
     ).run(id);
@@ -182,6 +184,10 @@ export async function signOffTask(
   return policy.method;
 }
 
+// Between `gh pr merge` and the end of the tidying after it.
+export const isMerging = (id: string): boolean =>
+  signingOff.has(id) || afterMerge.has(id);
+
 export function mergeSettled(id: string): Promise<void> {
   return afterMerge.get(id) ?? Promise.resolve();
 }
@@ -212,6 +218,7 @@ export async function dropTask(id: string): Promise<void> {
   db.prepare(`UPDATE sessions SET task_status = 'dropped' WHERE id = ?`).run(
     id
   );
+  endPauseOnFinish(id);
   db.prepare(
     `UPDATE stack_items SET status = 'dropped' WHERE session_id = ?`
   ).run(id);

package/lib/tasks/move-carry.ts

@@ -31,6 +31,7 @@ export const REKEYED = [
 export const KEPT = [
   ["orchestrator_event_log", "subject", "history is never rewritten"],
   ["stack_items", "session_id", "stacked tasks don't move"],
+  ["task_pauses", "session_id", "a paused task can't be moved"],
   [
     "task_queue",
     "after_any",

package/lib/tasks/move-flow.ts

@@ -42,6 +42,12 @@ export function assertMovable(id: string, toHostId: string): Session {
   const session = getTaskSession(id);
   if (!LIVE.has(session.task_status ?? ""))
     throw new Error(`Task is already ${session.task_status}`);
+  if (session.pause_state)
+    throw new Error(
+      session.pause_state === "paused"
+        ? "It's paused: resume it first"
+        : `It's ${session.pause_state}: let that finish first`
+    );
   const fromRemote = isRemoteHost(session.host_id);
   const toRemote = isRemoteHost(toHostId);
   if (fromRemote === toRemote) {

package/lib/tasks/pause-hold.ts

@@ -0,0 +1,70 @@
+// Whether a session is paused, from the database alone, so the message bus
+// can hold a message for it without loading the pause machinery.
+
+import { db, type TaskPause } from "../db";
+
+export interface PauseHold {
+  pauseId: number;
+  until: string | null;
+}
+
+export function pauseHoldOf(sessionId: string): PauseHold | null {
+  const row = db
+    .prepare(
+      `SELECT pause_id, paused_until FROM sessions
+       WHERE id = ? AND pause_state IN ('pausing', 'paused') AND pause_id IS NOT NULL`
+    )
+    .get(sessionId) as
+    | { pause_id: number; paused_until: string | null }
+    | undefined;
+  return row ? { pauseId: row.pause_id, until: row.paused_until } : null;
+}
+
+// A stored time (UTC, no zone) as this server's clock reads it.
+export function formatUntil(stored: string): string {
+  const t = Date.parse(`${stored.replace(" ", "T")}Z`);
+  return new Date(t).toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  });
+}
+
+// What a sender is told when their message is held.
+export function pausedNote(name: string, hold: PauseHold): string {
+  return `${name} is paused${hold.until ? ` until ${formatUntil(hold.until)}` : ""}; it gets this when it resumes`;
+}
+
+export function endPause(
+  row: Pick<TaskPause, "id" | "session_id">,
+  reason: "resumed" | "cancelled" | "finished" | "failed"
+): void {
+  db.transaction(() => {
+    db.prepare(
+      `UPDATE task_pauses SET state = 'ended', ended_at = datetime('now'), end_reason = ?
+       WHERE id = ? AND state != 'ended'`
+    ).run(reason, row.id);
+    db.prepare(
+      `UPDATE sessions SET pause_state = NULL, paused_until = NULL, pause_id = NULL
+       WHERE id = ? AND pause_id = ?`
+    ).run(row.session_id, row.id);
+  })();
+}
+
+// A task that merged, was dropped or was marked done is no longer paused.
+// What was held stays as history, read.
+export function endPauseOnFinish(sessionId: string): void {
+  const row = db
+    .prepare(
+      `SELECT id, session_id FROM task_pauses WHERE session_id = ? AND state != 'ended'
+       ORDER BY id DESC LIMIT 1`
+    )
+    .get(sessionId) as { id: number; session_id: string } | undefined;
+  if (!row) return;
+  endPause(row, "finished");
+  db.prepare(
+    `UPDATE bus_messages SET read_at = COALESCE(read_at, datetime('now'))
+     WHERE held_pause_id = ?`
+  ).run(row.id);
+}