@saadnvd1/agent-os 0.3.571 → 0.3.572

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

package/lib/tasks/pause-policy.ts

@@ -0,0 +1,130 @@
+/**
+ * The rules of a timed pause, as pure functions: what can't be paused, who
+ * may undo whose pause, and the one prompt a session gets when it resumes.
+ */
+
+import type { PauseBy } from "./schedule-types";
+
+export interface PauseFacts {
+  // A task (it holds a slot) as opposed to a plain chat or terminal session.
+  isTask: boolean;
+  isOrchestrator: boolean;
+  isQuickChange: boolean;
+  // Runs on, or is a mirror of, a linked machine.
+  isRemote: boolean;
+  taskStatus: string | null;
+  pauseState: string | null;
+  // Moving, or its stack is landing.
+  held: boolean;
+  // Between `gh pr merge` and the database knowing it, or tidying after.
+  merging: boolean;
+  settingUp: boolean;
+  // Waiting on a person.
+  chatWaiting: boolean;
+  terminalWaiting: boolean;
+  openAsk: boolean;
+  openQuestion: boolean;
+  escalated: boolean;
+  planAwaiting: boolean;
+  // A terminal whose agent can be started again from its saved conversation
+  // (Claude with a conversation id). A chat always can.
+  resumable: boolean;
+}
+
+// Why it can't be paused now, or null.
+export function pauseRefusal(f: PauseFacts): string | null {
+  if (f.isOrchestrator)
+    return "An orchestrator is paused with its workspace's Pause, not on its own";
+  if (f.isQuickChange)
+    return "A quick change runs no agent, so there is nothing to pause";
+  if (f.isRemote) return "It runs on another machine: pause it from there";
+  if (!f.resumable)
+    return "Its agent can't be started again from where it stopped, so it can't be paused";
+  if (f.isTask && f.taskStatus && f.taskStatus !== "running")
+    return `It's ${f.taskStatus}, not running`;
+  if (f.pauseState === "paused") return "It's already paused";
+  if (f.merging) return "It's merging";
+  if (f.held) return "It's moving to another machine or its stack is landing";
+  if (f.settingUp) return "It's still setting up; pause it once it has started";
+  if (
+    f.chatWaiting ||
+    f.terminalWaiting ||
+    f.openAsk ||
+    f.openQuestion ||
+    f.escalated ||
+    f.planAwaiting
+  )
+    return "It's waiting on you";
+  return null;
+}
+
+const RANK: Record<PauseBy, number> = {
+  scheduler: 1,
+  orchestrator: 2,
+  person: 3,
+};
+
+// A pause is lifted by its own kind or a higher one: a person above the
+// orchestrator above the scheduler.
+export function mayResume(actor: PauseBy, pausedBy: PauseBy): boolean {
+  return RANK[actor] >= RANK[pausedBy];
+}
+
+export function resumeRefusal(
+  actor: PauseBy,
+  pausedBy: PauseBy,
+  untilLabel: string | null
+): string | null {
+  if (mayResume(actor, pausedBy)) return null;
+  const who = pausedBy === "person" ? "a person" : "the orchestrator";
+  return `Paused by ${who}${untilLabel ? ` until ${untilLabel}` : ""}; only ${pausedBy === "person" ? "they" : "the orchestrator or a person"} can resume it`;
+}
+
+export interface HeldMessage {
+  from: string;
+  text: string;
+}
+
+const BY_TEXT: Record<PauseBy, string> = {
+  person: "by the user",
+  orchestrator: "by the orchestrator",
+  scheduler: "by the scheduler because the machine was loaded",
+};
+
+export function durationText(fromMs: number, untilMs: number | null): string {
+  if (untilMs === null) return "until resumed";
+  const minutes = Math.max(1, Math.round((untilMs - fromMs) / 60_000));
+  if (minutes < 90) return `for ${minutes} minute${minutes === 1 ? "" : "s"}`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return `for ${hours} hour${hours === 1 ? "" : "s"}`;
+  const days = Math.round(hours / 24);
+  return `for ${days} days`;
+}
+
+// The prompt a resumed session gets, with everything held while it was
+// paused folded in.
+export function continuePrompt(input: {
+  pausedAt: string;
+  by: PauseBy;
+  duration: string;
+  interrupted: boolean;
+  held: HeldMessage[];
+}): string {
+  const lines = [
+    `You were paused at ${input.pausedAt} (${BY_TEXT[input.by]}, ${input.duration}) and are resumed now.${
+      input.interrupted
+        ? " Your last step was interrupted; check whether it finished before redoing it."
+        : ""
+    }`,
+  ];
+  if (input.held.length) {
+    lines.push(
+      `While you were paused, ${input.held.length} message${input.held.length === 1 ? "" : "s"} arrived:`,
+      ...input.held.map((m, i) => `${i + 1}. From ${m.from}: ${m.text}`)
+    );
+  }
+  lines.push(
+    "Check the worktree, the branch against its PR and CI before you continue, then carry on with the task."
+  );
+  return lines.join("\n");
+}