@saadnvd1/agent-os 0.3.630 → 0.3.637

package/lib/tasks/held.ts

@@ -8,6 +8,7 @@
 import { orchestratorOf } from "./starter";
 import os from "os";
 import { db, type Session } from "../db";
+import { isRemoteHost } from "../hosts";
 import type { OrchestratedBundle } from "./move-bundle";
 
 export function holderRefusal(
@@ -133,3 +134,25 @@ export function holdExisting(
   holdFor(id, device, held);
   return true;
 }
+
+/**
+ * A plan another machine placed here is read and approved by that machine
+ * only: it decides where the task is built. Null for any other task.
+ */
+export function planWaitRefusal(
+  id: string,
+  device: string | null | undefined
+): string | null {
+  const s = db
+    .prepare(
+      `SELECT plan_waits_for_caller, started_by_device, host_id FROM sessions WHERE id = ?`
+    )
+    .get(id) as
+    | Pick<Session, "plan_waits_for_caller" | "started_by_device" | "host_id">
+    | undefined;
+  if (!s?.plan_waits_for_caller) return null;
+  // The placing machine's own mirror of the plan: its people decide it.
+  if (isRemoteHost(s.host_id)) return null;
+  if (device && device === s.started_by_device) return null;
+  return "The machine that placed this plan decides it; approve it from there";
+}

package/lib/tasks/hold-checks.ts

@@ -0,0 +1,134 @@
+/**
+ * The holds that read the database or this machine, each returning `Hold`s
+ * (holds.ts) so every caller that asks "may this start now" gets the same
+ * answer and the same words: the orchestrator's Pause and the usage window,
+ * `after`, and this machine's load for a start here.
+ */
+
+import type { Session } from "../db";
+import { getProject } from "../projects";
+import { isRemoteHost } from "../hosts";
+import { isPaused } from "../orchestrator/pause";
+import { brakesEnabled } from "../orchestrator/brakes";
+import { readUsage, windowRefusal } from "../orchestrator/usage";
+import { localView, machineCapabilities } from "../load/machines";
+import { DEFAULT_PRIORITY, type Priority } from "./schedule-types";
+import { machineHolds, holdReason, type Hold } from "./holds";
+import { heavyNeeds, meetsNeeds, needsOf, type Need } from "./placement";
+import { expandHome } from "./session";
+import { afterLabel, hasFinished } from "./queue-rows";
+import type { QueueRow } from "./queue-types";
+import type { PauseBy } from "./schedule-types";
+
+// Why an automatic start has to wait: the orchestrator's Pause, then the
+// usage window. A start now by a person isn't held, and a plan-only start
+// is held by Pause alone.
+export function autoHolds(
+  workspaceId: string | null,
+  planOnly = false
+): Hold[] {
+  const out: Hold[] = [];
+  if (workspaceId && isPaused(workspaceId))
+    out.push({
+      code: "orch_paused",
+      text: "Waiting: the orchestrator is paused",
+    });
+  if (planOnly) return out;
+  const window = brakesEnabled() ? windowRefusal(readUsage()) : null;
+  if (window) out.push({ code: "window", text: `Waiting: ${window}` });
+  return out;
+}
+
+export const autoHold = (
+  workspaceId: string | null,
+  planOnly = false
+): Hold | null => autoHolds(workspaceId, planOnly)[0] ?? null;
+
+// `after X`: the task it waits on hasn't finished.
+export function afterHold(r: QueueRow): Hold | null {
+  if (!r.after_task || hasFinished(r.after_task)) return null;
+  return {
+    code: "after",
+    text: `After ${afterLabel({ ...r, after_any: null }) ?? "its task"}`,
+  };
+}
+
+// What this machine would say to a start of a task with these needs here
+// and now: empty means it may start.
+export function localHolds(
+  ask: { needs: Need[]; priority?: Priority },
+  now = Date.now()
+): Hold[] {
+  return machineHolds(
+    {
+      heavy: heavyNeeds(ask.needs),
+      needsUnmet: !meetsNeeds(ask.needs, machineCapabilities()),
+      remote: false,
+      priority: ask.priority ?? DEFAULT_PRIORITY,
+    },
+    localView(now),
+    now
+  );
+}
+
+export const requestNeeds = (
+  projectId: string,
+  workingDirectory: string,
+  prompt: string,
+  setting: Need[] | null
+): Need[] =>
+  setting ??
+  needsOf({
+    projectId,
+    projectPath: expandHome(workingDirectory),
+    prompt,
+  }).needs;
+
+// Whether the task needs something this machine lacks (a Mac).
+export function needsUnmetHere(
+  projectId: string,
+  prompt: string,
+  setting: Need[] | null
+): boolean {
+  const project = getProject(projectId);
+  if (!project || isRemoteHost(project.host_id)) return false;
+  return !meetsNeeds(
+    requestNeeds(projectId, project.working_directory, prompt, setting),
+    machineCapabilities()
+  );
+}
+
+// Whether this machine's load rules out starting a task for this project now.
+export function loadHeldStart(
+  projectId: string,
+  prompt: string,
+  setting: Need[] | null
+): boolean {
+  const project = getProject(projectId);
+  if (!project || isRemoteHost(project.host_id)) return false;
+  const head = localHolds({
+    needs: requestNeeds(projectId, project.working_directory, prompt, setting),
+  })[0];
+  return head?.code === "load_red" || head?.code === "heavy";
+}
+
+// Why this machine's load rules out starting an agent now, or null. Only a
+// red (or still settling) machine holds a resume; amber doesn't.
+export function loadHoldFor(s: Session): string | null {
+  const project = s.project_id ? getProject(s.project_id) : null;
+  if (!project || isRemoteHost(s.host_id ?? project.host_id)) return null;
+  const hold = localHolds({ needs: [] })[0];
+  return hold?.code === "load_red" ? holdReason(hold) : null;
+}
+
+// Why a resume this actor asked for must wait: this machine's load, and for
+// the orchestrator also what holds its own starts (it is paused, or the
+// usage window). A person's own resume skips the second.
+export function resumeHoldFor(s: Session, actor: PauseBy): string | null {
+  const load = loadHoldFor(s);
+  if (load) return load;
+  if (actor !== "orchestrator") return null;
+  const ws = s.project_id ? getProject(s.project_id)?.workspace_id : null;
+  const hold = autoHold(ws ?? null);
+  return hold ? holdReason(hold) : null;
+}

package/lib/tasks/holds.ts

@@ -0,0 +1,281 @@
+/**
+ * Every reason a task waits, as one type and one ordered list. A hold is
+ * pure data: `holdsFor` turns a candidate and what we know of its machine
+ * into the holds that apply, always in HOLD_ORDER, and the first is the
+ * reason shown. The queue view, a queued row's note, a paused task's resume
+ * note and the start decision all read that list, so "why is this waiting"
+ * has one source. No database and no clock of its own: the checks that need
+ * either are in hold-checks.ts.
+ */
+
+import {
+  DEFAULT_PRIORITY,
+  type Priority,
+  type WaitCode,
+} from "./schedule-types";
+import type { Candidate } from "./schedule";
+
+// Out of red this long before automatic starts resume.
+export const LOAD_SETTLE_MS = 120_000;
+// On amber, only this priority and above start.
+export const AMBER_MIN_PRIORITY: Priority = "blocking";
+// Between automatic starts on one machine.
+export const START_GAP_MS = 60_000;
+// Between starts of tasks that boot a simulator.
+export const HEAVY_START_GAP_MS = 5 * 60_000;
+
+export const PRIORITY_POINTS: Record<Priority, number> = {
+  urgent: 400,
+  blocking: 300,
+  normal: 200,
+  background: 100,
+};
+const priorityRank = (p: Priority) => PRIORITY_POINTS[p] ?? 0;
+
+export type MachineLevel = "green" | "amber" | "red";
+
+// What the machine a candidate would start on looks like right now.
+export interface MachineView {
+  // Shown in hold texts, e.g. "this machine".
+  label: string;
+  // False: no load holds at all (AGENTOS_LOAD=off).
+  enabled: boolean;
+  // No sample read yet since AgentOS started.
+  reading: boolean;
+  level: MachineLevel;
+  // Not red, and calm for LOAD_SETTLE_MS since it last was.
+  settled: boolean;
+  // Seconds of calm still needed, when not settled and not red.
+  settleLeftMs: number;
+  booted: number;
+  maxBooted: number;
+  // Heavy tasks started within HEAVY_START_GAP_MS that hold no lease yet.
+  heavyStarting: number;
+  lastAutoStartAt: number | null;
+  lastHeavyStartAt: number | null;
+}
+
+export type MachineCode =
+  | "needs"
+  | "load_red"
+  | "load_amber"
+  | "heavy"
+  | "spacing";
+
+// A reason a task isn't starting. `code` is also what a queue row stores and
+// the client reads. A hold that rests on a machine says which one, and when
+// it knows, the time (ms) it lifts.
+export type Hold =
+  | { code: "after"; text: string }
+  | { code: "after_any"; text: string }
+  | { code: "orch_paused"; text: string }
+  | { code: "window"; text: string }
+  | {
+      code: MachineCode;
+      text: string;
+      machine: string;
+      until?: number;
+      // Why it waits here instead of starting on a linked machine.
+      stay?: string;
+    }
+  | { code: "slot"; text: string };
+
+// The order holds are reported in; the first that applies is the reason.
+export const HOLD_ORDER: readonly WaitCode[] = [
+  "after",
+  "after_any",
+  "orch_paused",
+  "window",
+  "needs",
+  "load_red",
+  "load_amber",
+  "heavy",
+  "spacing",
+  "slot",
+];
+
+// Whether the hold lifts without anyone acting. A Pause is lifted by a
+// person, and a task that needs a Mac never gets one by waiting.
+const CLEARS_BY_ITSELF: Record<WaitCode, boolean> = {
+  after: true,
+  after_any: true,
+  orch_paused: false,
+  window: true,
+  needs: false,
+  load_red: true,
+  load_amber: true,
+  heavy: true,
+  spacing: true,
+  slot: true,
+};
+
+export const clearsByItself = (h: Hold): boolean => CLEARS_BY_ITSELF[h.code];
+
+// The holds a linked machine could lift by taking the start.
+const PLACEABLE = new Set<WaitCode>([
+  "load_red",
+  "load_amber",
+  "heavy",
+  "needs",
+]);
+
+export const placeable = (h: Pick<Hold, "code">): boolean =>
+  PLACEABLE.has(h.code);
+
+// The text a person sees: the hold, and for a task that can't go elsewhere,
+// why it stays here.
+export function holdText(h: Hold): string {
+  return "stay" in h && h.stay ? `${h.text} (${h.stay})` : h.text;
+}
+
+// The same without the "Waiting: " lead, for a note that has its own.
+export const holdReason = (h: Hold): string =>
+  holdText(h).replace(/^Waiting: /, "");
+
+// What a row stores of its first hold: null code and text when none.
+export function queueNote(holds: readonly Hold[] | undefined): {
+  code: WaitCode | null;
+  text: string | null;
+} | null {
+  if (!holds) return null;
+  const head = holds[0];
+  return head
+    ? { code: head.code, text: holdText(head) }
+    : { code: null, text: null };
+}
+
+// What a timed resume waiting for its turn says on its task.
+export function resumeNote(
+  holds: readonly Hold[] | undefined,
+  slots: { running: number; limit: number | null }
+): string | null {
+  if (!holds) return null;
+  const head = holds[0];
+  if (head && head.code !== "slot") return `held: ${holdReason(head)}`;
+  return slots.limit === null
+    ? "resuming: waiting for its turn"
+    : `resuming: waiting for a slot, ${slots.running} of ${slots.limit} running`;
+}
+
+const seconds = (ms: number) => Math.max(1, Math.ceil(ms / 1000));
+
+export function slotText(rank: number, of: number, priority: Priority): string {
+  const word = priority === DEFAULT_PRIORITY ? "" : ` · ${priority}`;
+  return `#${rank} of ${of}${word}`;
+}
+
+type MachineAsk = Pick<
+  Candidate,
+  "heavy" | "needsUnmet" | "remote" | "priority"
+> &
+  Partial<Pick<Candidate, "planOnly">>;
+
+// The holds the machine puts on a start, in order. Empty: it may start here
+// now. A machine with no reading yet says only that; one with load checks
+// off says only what it lacks.
+export function machineHolds(
+  c: MachineAsk,
+  m: MachineView,
+  now: number
+): Hold[] {
+  if (c.remote || c.planOnly) return [];
+  const out: Hold[] = [];
+  const add = (code: MachineCode, text: string, until?: number): void => {
+    out.push({
+      code,
+      text: `Waiting: ${text}`,
+      machine: m.label,
+      ...(until === undefined ? {} : { until }),
+    });
+  };
+  if (c.needsUnmet) add("needs", "needs a Mac");
+  if (!m.enabled) return out;
+  if (m.reading) {
+    add("load_red", "reading machine load");
+    return out;
+  }
+  if (m.level === "red") add("load_red", `${m.label} load red`);
+  else if (!m.settled)
+    add(
+      "load_red",
+      `${m.label} load was red; calm for ${seconds(m.settleLeftMs)}s more`,
+      now + m.settleLeftMs
+    );
+  else if (
+    m.level === "amber" &&
+    priorityRank(c.priority) < priorityRank(AMBER_MIN_PRIORITY)
+  )
+    add(
+      "load_amber",
+      `${m.label} load amber; ${c.priority} work starts on green`
+    );
+  if (c.heavy && m.level !== "red") {
+    if (m.level !== "green")
+      add("heavy", `${m.label} load amber; simulator work starts on green`);
+    else if (m.heavyStarting > 0)
+      add("heavy", `a simulator is booting on ${m.label}`);
+    else if (m.booted >= m.maxBooted)
+      add("heavy", `${m.booted} of ${m.maxBooted} simulators in use`);
+    else if (
+      m.lastHeavyStartAt !== null &&
+      now - m.lastHeavyStartAt < HEAVY_START_GAP_MS
+    )
+      add(
+        "heavy",
+        `a simulator task just started on ${m.label} (next in ${seconds(HEAVY_START_GAP_MS - (now - m.lastHeavyStartAt))}s)`,
+        m.lastHeavyStartAt + HEAVY_START_GAP_MS
+      );
+  }
+  if (m.lastAutoStartAt !== null && now - m.lastAutoStartAt < START_GAP_MS)
+    add(
+      "spacing",
+      `spacing starts (next in ${seconds(START_GAP_MS - (now - m.lastAutoStartAt))}s)`,
+      m.lastAutoStartAt + START_GAP_MS
+    );
+  return out;
+}
+
+// The first machine hold, or null: the one every placement check asks.
+export const machineHold = (
+  c: MachineAsk,
+  m: MachineView,
+  now: number
+): Hold | null => machineHolds(c, m, now)[0] ?? null;
+
+export interface HoldContext {
+  machine: MachineView;
+  now: number;
+  // Finishes other waiters have already taken this look.
+  used: ReadonlySet<string>;
+  // Running tasks in its line, and the line's limit.
+  inFlight: number;
+  limit: number;
+  // Its place in the line's score order.
+  rank: number;
+  of: number;
+}
+
+// Every hold on a candidate, in HOLD_ORDER. The first is why it waits; none:
+// it starts.
+export function holdsFor(c: Candidate, ctx: HoldContext): Hold[] {
+  const out: Hold[] = [];
+  if (c.before) out.push(c.before);
+  if (c.any && !c.any.released) {
+    const free = c.any.finished.some((id) => !ctx.used.has(id));
+    const spent =
+      c.any.ids.length > 0 && c.any.finished.length === c.any.ids.length;
+    if (!free && !spent)
+      out.push({
+        code: "after_any",
+        text: `Waiting: after any running task (${c.any.label})`,
+      });
+  }
+  if (c.auto) out.push(...([] as Hold[]).concat(c.auto));
+  out.push(...machineHolds(c, ctx.machine, ctx.now));
+  if (!c.planOnly && ctx.inFlight >= ctx.limit)
+    out.push({
+      code: "slot",
+      text: slotText(ctx.rank, ctx.of, c.priority),
+    });
+  return out;
+}

package/lib/tasks/import.ts

@@ -118,9 +118,10 @@ async function arrive(
   };
   stepProgress(bundle.moveId, "conversation");
   // The plan is never in git: it comes in the bundle.
-  if (orch?.planFile != null) {
+  const planFile = bundle.planWait?.file ?? orch?.planFile ?? null;
+  if (planFile != null) {
     preparePlanDir(worktreePath);
-    fs.writeFileSync(path.join(worktreePath, PLAN_FILE), orch.planFile);
+    fs.writeFileSync(path.join(worktreePath, PLAN_FILE), planFile);
   }
   if (claude && paths) {
     await writeTranscript(
@@ -169,6 +170,10 @@ async function arrive(
          claude_session_id = ?, moved_from = ? WHERE id = ?`
     ).run(bundle.prompt, brief, claude?.sessionId ?? null, bundle.moveId, id);
     if (bundle.chat) unpackChat(id, bundle.chat, paths);
+    if (bundle.planWait)
+      db.prepare(
+        `UPDATE sessions SET plan_phase = 'awaiting' WHERE id = ?`
+      ).run(id);
     if (orch) {
       db.prepare(
         `UPDATE sessions SET plan_phase = ?, task_since = ? WHERE id = ?`
@@ -205,7 +210,10 @@ async function arrive(
     }
     const note = arrivalNote(bundle, worktreePath, os.hostname());
     const prompt = claude ? note : `${bundle.prompt}\n\n${note}`;
-    if (bundle.chat) {
+    if (bundle.planWait) {
+      // Waiting on its plan's approval: nothing runs until the message that
+      // implements it, which resumes the carried conversation.
+    } else if (bundle.chat) {
       // Its worker starts on the carried conversation, takes the note
       // first, then what was queued.
       await sendChat(id, {

package/lib/tasks/index.ts

@@ -173,6 +173,9 @@ export async function createTask(opts: {
   held?: { device: string; orchestrated: OrchestratedBundle };
   // The paired device that sent this keyed start: the only one that may hold it later.
   startedByDevice?: string | null;
+  // Another machine placed this plan here and decides what follows it: the
+  // task plans, then waits for that machine (implies planOnly).
+  planWaits?: boolean;
 }): Promise<Session> {
   if (opts.id) {
     const existing = queries.getSession(db).get(opts.id) as Session | undefined;
@@ -244,12 +247,27 @@ async function startTask(
       throw new Error(`${agentLabel(agent)} tasks run on this machine for now`);
   }
   if (isRemoteHost(hostId)) {
-    if (opts.planOnly)
-      throw new Error("A plan-only task runs on this machine for now");
     if (opts.base || opts.cardId)
       throw new Error(
         "Stacked and card tasks run on this machine only for now"
       );
+    if (opts.planOnly && opts.plan === false)
+      throw new Error(
+        "planOnly implies plan; it can't be combined with plan false"
+      );
+    if (opts.planOnly && view !== "chat")
+      throw new Error("A plan-only task needs a chat, not a terminal");
+    // The plan step is this machine's to run and decide: it plans there,
+    // stops, and what follows is chosen here (remote-plan.ts).
+    const planned =
+      !!(opts.plan || opts.planOnly) &&
+      taskRouting(
+        project.workspace_id,
+        view,
+        opts.model,
+        opts.plan,
+        opts.planOnly
+      ).plan;
     const session = await startRemoteTask(hostId, project, {
       id,
       prompt,
@@ -258,6 +276,9 @@ async function startTask(
       baseBranch: opts.baseBranch,
       view,
       startedBy: opts.startedBy,
+      plan: planned
+        ? { only: !!opts.planOnly, reason: opts.planReason?.trim() || null }
+        : undefined,
     });
     // The mirror's started_by stays orchestrator-only: a held-remote task is
     // relayed, stopped and answered through it. A plain calling task is its
@@ -347,7 +368,7 @@ async function startTask(
     db.prepare(
       `UPDATE sessions SET task_prompt = ?, task_brief = ?, task_status = 'running', setup_status = 'running', name_source = ?, view = ?,
          model_provider = ?, model_overrides = ?, plan_phase = ?, plan_only = ?,
-         plan_decided = ?, plan_reason = ? WHERE id = ?`
+         plan_decided = ?, plan_reason = ?, plan_waits_for_caller = ? WHERE id = ?`
     ).run(
       prompt,
       buildTaskBrief({
@@ -366,6 +387,7 @@ async function startTask(
       routing.planOnly ? 1 : null,
       routing.planOnly ? 1 : opts.plan === undefined ? null : opts.plan ? 1 : 0,
       opts.planReason?.trim() || null,
+      routing.planOnly && opts.planWaits ? 1 : null,
       id
     );
     recordStart(id, {

package/lib/tasks/move-bundle.ts

@@ -57,6 +57,10 @@ export interface TaskBundle {
   // What a task started by an orchestrator carries besides its work; absent
   // for any other task, or from a machine that predates these moves.
   orchestrated?: OrchestratedBundle;
+  // A plan written and waiting for the machine that placed it (it is moving
+  // there to be built): the plan file, which is never in git. The arriving
+  // machine runs no turn; the approval that follows starts one.
+  planWait?: { file: string | null };
 }
 
 export interface OrchestratedBundle {
@@ -70,7 +74,7 @@ export interface OrchestratedBundle {
   // machine without that provider refuses the task rather than change it.
   modelProvider: string | null;
   modelOverrides: string | null;
-  planPhase: "planning" | "implementing" | null;
+  planPhase: "planning" | "awaiting" | "implementing" | null;
   // .agentos/plan.md, which is never in git.
   planFile: string | null;
   // The orchestrator that holds the task (its id and name on the machine
@@ -153,7 +157,7 @@ function validateChat(c: ChatBundle): ChatBundle {
   return { ...c, plan: !!c.plan };
 }
 
-const PHASES = ["planning", "implementing"];
+const PHASES = ["planning", "awaiting", "implementing"];
 
 export function validateOrchestrated(
   o: OrchestratedBundle
@@ -196,6 +200,16 @@ export function validateOrchestrated(
   };
 }
 
+function validatePlanWait(w: unknown): TaskBundle["planWait"] {
+  if (w === undefined || w === null) return undefined;
+  const file = (w as { file?: unknown }).file;
+  if (typeof w !== "object" || !(file === null || isStr(file)))
+    throw new Error("Bad plan");
+  if ((file?.length ?? 0) > MAX_PLAN_BYTES)
+    throw new Error("The plan is too large to move");
+  return { file };
+}
+
 export function validateBundle(b: TaskBundle): TaskBundle {
   if (!b || typeof b !== "object") throw new Error("No task to import");
   if (!isSessionId(b.moveId)) throw new Error("Bad move id");
@@ -228,6 +242,7 @@ export function validateBundle(b: TaskBundle): TaskBundle {
     orchestrated: b.orchestrated
       ? validateOrchestrated(b.orchestrated)
       : undefined,
+    planWait: validatePlanWait(b.planWait),
     chat: b.chat ? validateChat(b.chat) : undefined,
     name: b.name.slice(0, 200),
     from: String(b.from || "another machine")

package/lib/tasks/move-guard.ts

@@ -29,7 +29,15 @@ export function moveRefusal(session: Session): string | null {
     return "Its repo is encrypted with git-crypt and the key never leaves this machine, so it stays here";
   if (escalations(session.id).length)
     return "It's waiting on you (an escalated gate), so it stays here";
-  if (session.plan_only && session.plan_phase !== "implementing")
+  if (
+    session.plan_only &&
+    session.plan_phase !== "implementing" &&
+    // A plan another machine placed here moves to it once written.
+    !(
+      session.plan_waits_for_caller &&
+      (session.plan_phase === "awaiting" || session.plan_phase === "handoff")
+    )
+  )
     return "It's a plan-only task that hasn't been approved, so it stays here";
   const ask = db
     .prepare(

package/lib/tasks/move.ts

@@ -140,10 +140,7 @@ function orchestratedBundle(session: Session): OrchestratedBundle {
     modelProvider: session.model_provider ?? null,
     modelOverrides: session.model_overrides ?? null,
     // moveRefusal keeps an unapproved plan-only task here.
-    planPhase: (session.plan_phase ?? null) as
-      | "planning"
-      | "implementing"
-      | null,
+    planPhase: (session.plan_phase ?? null) as OrchestratedBundle["planPhase"],
     planFile: readPlanFile(session.working_directory),
     orchestrator: orchestratorOf(session),
   };
@@ -215,6 +212,10 @@ export async function exportTask(id: string, to: string): Promise<TaskBundle> {
           : null,
       chat: chatBundle,
       orchestrated: isOrchestrated(now) ? orchestratedBundle(now) : undefined,
+      planWait:
+        now.plan_waits_for_caller && now.plan_phase === "awaiting"
+          ? { file: readPlanFile(cwd) }
+          : undefined,
     };
   } finally {
     packed();

package/lib/tasks/pause.ts

@@ -34,9 +34,7 @@ import { openBySubject, workSubject } from "../orchestrator/asks";
 import { queueEventOnce } from "../orchestrator/events";
 import { isPaused } from "../orchestrator/pause";
 import { isMerging } from "./finish";
-import { autoHold } from "./auto-hold";
-import { localView } from "../load/machines";
-import { machineHold } from "./schedule";
+import { loadHoldFor, resumeHoldFor } from "./hold-checks";
 import {
   continuePrompt,
   durationText,
@@ -395,34 +393,7 @@ export function requestResume(sessionId: string, actor: PauseBy): void {
     );
 }
 
-// Why this machine's load rules out starting an agent now, or null. Only a
-// red (or still settling) machine holds a resume; amber doesn't.
-export function loadHoldFor(s: Session): string | null {
-  const project = s.project_id ? getProject(s.project_id) : null;
-  if (!project || isRemoteHost(s.host_id ?? project.host_id)) return null;
-  const hold = machineHold(
-    {
-      heavy: false,
-      needsUnmet: false,
-      remote: false,
-      priority: DEFAULT_PRIORITY,
-    },
-    localView(),
-    Date.now()
-  );
-  return hold?.code === "load_red" ? hold.text.replace(/^Waiting: /, "") : null;
-}
-
-// Why a resume this actor asked for must wait: this machine's load, and for
-// the orchestrator also what holds its own starts (it is paused, or the
-// usage window). Saad's own resume skips the second.
-export function resumeHoldFor(s: Session, actor: PauseBy): string | null {
-  const load = loadHoldFor(s);
-  if (load) return load;
-  if (actor !== "orchestrator") return null;
-  const ws = s.project_id ? getProject(s.project_id)?.workspace_id : null;
-  return autoHold(ws ?? null)?.text.replace(/^Waiting: /, "") ?? null;
-}
+export { loadHoldFor, resumeHoldFor };
 
 export function setPauseNote(sessionId: string, note: string | null): void {
   db.prepare(