@saadnvd1/agent-os 0.3.592 → 0.3.595

package/lib/tasks/queue.ts

@@ -22,6 +22,7 @@ import { getProject } from "../projects";
 import { isRemoteHost } from "../hosts";
 import { getWorkspace } from "../workspaces";
 import { isPaused } from "../orchestrator/pause";
+import { autoHold } from "./auto-hold";
 import {
   BrakeRefused,
   braked,
@@ -77,7 +78,13 @@ import { peerReading, peerSource, refreshPeers } from "../hosts/peer-load";
 import { hostLink, linkedHostIds } from "../hosts/remote-api";
 import { hostTasks } from "./remote";
 import { projectMachines } from "../hosts/project-machines";
-import { claimResume, dueResumes } from "./pause";
+import {
+  type DueResume,
+  claimResume,
+  dueResumes,
+  resumeHoldFor,
+  setPauseNote,
+} from "./pause";
 
 export type QueueStatus =
   | "queued"
@@ -562,16 +569,6 @@ const sqliteMs = (v: string) =>
 export const queuedView = (id: string) =>
   listQueue().find((q) => q.id === id) ?? null;
 
-// Why an automatic start has to wait, or null. A start now by a person
-// isn't held.
-function autoHold(workspaceId: string | null, planOnly = false): Hold | null {
-  if (workspaceId && isPaused(workspaceId))
-    return { code: "orch_paused", text: "Waiting: the orchestrator is paused" };
-  if (planOnly) return null;
-  const window = brakesEnabled() ? windowRefusal(readUsage()) : null;
-  return window ? { code: "window", text: `Waiting: ${window}` } : null;
-}
-
 const requestNeeds = (
   projectId: string,
   workingDirectory: string,
@@ -959,7 +956,18 @@ export async function tickOnce(now = Date.now()): Promise<"stale" | void> {
        WHERE q.status IN ('queued', 'starting') ORDER BY q.position`
     )
     .all() as QueueRowWithWorkspace[];
-  const resumes = dueResumes();
+  const due = dueResumes();
+  // A deliberate resume starts past the slot limit; only a red machine holds
+  // it, and the task says so.
+  for (const d of due.filter((x) => x.resumeBy)) {
+    const s = db
+      .prepare(`SELECT * FROM sessions WHERE id = ?`)
+      .get(d.sessionId) as Session | undefined;
+    const why = s ? resumeHoldFor(s, d.resumeBy!) : null;
+    if (why) setPauseNote(d.sessionId, `held: ${why}`);
+    else await claimResume(d.sessionId, { reason: d.resumeBy!, force: true });
+  }
+  const resumes = due.filter((x) => !x.resumeBy);
   if (!rows.length && !resumes.length) return;
   const queued = rows.filter((r) => r.status === "queued");
   const used = usedFinishes();
@@ -1051,6 +1059,11 @@ export async function tickOnce(now = Date.now()): Promise<"stale" | void> {
   const plan = planStarts(candidates, groups, home, now);
   for (const r of queued)
     noteWaiting(r, withStayReason(r, plan.explain.get(r.id)));
+  for (const d of resumes)
+    setPauseNote(
+      d.sessionId,
+      resumeWaitNote(d, plan.explain.get(`resume:${d.sessionId}`))
+    );
 
   for (const id of plan.start) {
     if (id.startsWith("resume:")) {
@@ -1067,6 +1080,20 @@ export async function tickOnce(now = Date.now()): Promise<"stale" | void> {
   }
 }
 
+// What a timed resume still waiting for its turn says on its task.
+function resumeWaitNote(
+  d: DueResume,
+  explain: { code: WaitCode | null; text: string | null } | undefined
+): string | null {
+  if (!explain) return null;
+  if (explain.code && explain.code !== "slot" && explain.text)
+    return `held: ${explain.text.replace(/^Waiting: /, "")}`;
+  const slots = slotState(d.projectId);
+  return slots.limit === null
+    ? "resuming: waiting for its turn"
+    : `resuming: waiting for a slot, ${slots.running} of ${slots.limit} running`;
+}
+
 // Writes why a row waits when that changed: its hold text and code. A bare
 // rank isn't stored (the view computes it), so the stream stays quiet.
 const MACHINE_HOLDS = new Set<WaitCode>([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.592",
+  "version": "0.3.595",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"