@saadnvd1/agent-os 0.3.630 → 0.3.637

package/lib/tasks/placement.ts

@@ -12,12 +12,8 @@ import path from "path";
 import { db } from "../db";
 import { loadProjectConfig } from "../project-config";
 import { MACHINE_NEEDS } from "../project-config/schema";
-import {
-  machineHold,
-  type Candidate,
-  type Hold,
-  type MachineView,
-} from "./schedule";
+import { machineHold, placeable, type MachineView } from "./holds";
+import type { Candidate } from "./schedule";
 
 export type Need = (typeof MACHINE_NEEDS)[number];
 export type NeedsSource = "task" | "brief" | "config" | "inferred" | "none";
@@ -138,8 +134,6 @@ export function unplaceable(r: {
   host_id: string | null;
 }): string | null {
   if (r.host_id) return "it was pinned to a machine";
-  if (r.plan_only) return "plan-only tasks run on this machine";
-  if (r.plan) return "plan-first tasks run on this machine";
   if (r.agent_type && r.agent_type !== "claude")
     return "only Claude tasks run on another machine";
   if (r.model_overrides) return "per-role models run on this machine";
@@ -153,11 +147,24 @@ export interface PeerOption {
   capabilities: string[];
   // It can hold an orchestrator's task (false: an older AgentOS). Unset: yes.
   holds?: boolean;
+  // It can run a plan step that stops for this machine (false: an older
+  // AgentOS). Unset: yes.
+  plans?: boolean;
   // The project exists there (projectMachines said null).
   hasProject: boolean;
   loadPerCore: number;
 }
 
+// A start that plans first: the plan phase only reads code, so it needs no
+// simulator or Mac, and the plan-only skip of load holds doesn't apply to
+// where it goes, only to whether it may wait. The candidate as a plan phase
+// sees it.
+export const asPlanPhase = <
+  T extends Pick<Candidate, "heavy" | "needsUnmet" | "planOnly">,
+>(
+  c: T
+): T => ({ ...c, heavy: false, needsUnmet: false, planOnly: false });
+
 export interface Placement {
   hostId: string;
   name: string;
@@ -165,13 +172,6 @@ export interface Placement {
   why: string;
 }
 
-const LOAD_HOLDS = new Set<Hold["code"]>([
-  "load_red",
-  "load_amber",
-  "needs",
-  "heavy",
-]);
-
 // True when the home machine's load or needs rule this start out, which is
 // the only time a linked machine is worth asking.
 export const wantsPlacing = (
@@ -181,7 +181,7 @@ export const wantsPlacing = (
 ): boolean => {
   if (c.remote || home.reading) return false;
   const hold = machineHold(c, home, now);
-  return !!hold && LOAD_HOLDS.has(hold.code);
+  return !!hold && placeable(hold);
 };
 
 // Null: start it at home (or hold it there for a reason placing doesn't

package/lib/tasks/plan-view.ts

@@ -17,6 +17,8 @@ import {
   type TaskPlan,
 } from "./loop-types";
 import { expandHome } from "./session";
+import { isRemoteHost } from "../hosts";
+import { remotePlanPath } from "./remote-plan-path";
 
 const TITLE_MAX = 120;
 
@@ -131,7 +133,10 @@ export function taskPlan(session: Session): TaskPlan | null {
     };
 
   if (phase && session.worktree_path) {
-    const file = path.join(expandHome(session.worktree_path), PLAN_FILE);
+    // A plan written on a linked machine is read from the copy kept here.
+    const file = isRemoteHost(session.host_id)
+      ? remotePlanPath(session.id)
+      : path.join(expandHome(session.worktree_path), PLAN_FILE);
     const text = readHead(file, PLAN_TEXT_MAX);
     if (text !== null || phase === "planning") {
       const body = text ?? "";
@@ -141,13 +146,16 @@ export function taskPlan(session: Session): TaskPlan | null {
         status:
           phase === "planning"
             ? "writing"
-            : phase === "awaiting"
+            : phase === "awaiting" || phase === "handoff"
               ? "ready"
               : "approved",
         source: "step",
         title: planTitle(body),
         path: text !== null ? PLAN_FILE : null,
-        pieces: phase === "awaiting" ? piecesView(session, file) : null,
+        pieces:
+          phase === "awaiting" || phase === "handoff"
+            ? piecesView(session, file)
+            : null,
         ...capped(body),
       };
     }

package/lib/tasks/queue-candidates.ts

@@ -0,0 +1,151 @@
+/**
+ * Building the candidates a look at the line scores: a fresh or retried start
+ * from a queue row, and a paused task that came due to resume. Each carries
+ * the holds that need the database (`after`, Pause, the usage window); the
+ * machine's holds are applied when the line is planned.
+ */
+
+import { getProject } from "../projects";
+import { isRemoteHost } from "../hosts";
+import { machineCapabilities } from "../load/machines";
+import {
+  claimResume,
+  resumeHoldFor,
+  setPauseNote,
+  type DueResume,
+} from "./pause";
+import {
+  heavyNeeds,
+  meetsNeeds,
+  needsOf,
+  parseNeeds,
+  type Need,
+} from "./placement";
+import { DEFAULT_PRIORITY, isPriority } from "./schedule-types";
+import type { Candidate, Group } from "./schedule";
+import { expandHome } from "./session";
+import { afterHold, autoHold } from "./hold-checks";
+import {
+  groupFor,
+  groupKey,
+  sessionOf,
+  sqliteMs,
+  stillWorking,
+  workspaceOf,
+} from "./queue-rows";
+import type { QueueRowWithWorkspace } from "./queue-types";
+
+export function candidateOf(
+  r: QueueRowWithWorkspace,
+  used: string[]
+): { c: Candidate; needs: Need[] } {
+  const project = getProject(r.project_id);
+  const hostId = r.host_id ?? project?.host_id;
+  const remote = isRemoteHost(hostId);
+  const needs = remote
+    ? []
+    : (parseNeeds(r.machine_needs) ??
+      (project
+        ? needsOf({
+            projectId: project.id,
+            projectPath: expandHome(project.working_directory),
+            prompt: r.prompt,
+          }).needs
+        : []));
+  let any: Candidate["any"] = null;
+  if (r.after_any) {
+    const ids = JSON.parse(r.after_any) as string[];
+    any = {
+      ids,
+      finished: ids.filter((id) => !stillWorking(id)),
+      used: used.filter((id) => id !== r.after_any_used),
+      released: !!r.after_any_used,
+      label:
+        ids
+          .filter(stillWorking)
+          .map((id) => sessionOf(id)?.name ?? id.slice(0, 8))
+          .join(", ") || "its set",
+    };
+  }
+  return {
+    needs,
+    c: {
+      id: r.id,
+      kind: "start",
+      group: groupKey(r.workspace_id, r.project_id),
+      priority: isPriority(r.priority) ? r.priority : DEFAULT_PRIORITY,
+      position: r.position,
+      waitingSinceMs: sqliteMs(r.created_at),
+      heavy: heavyNeeds(needs),
+      needsUnmet: !remote && !meetsNeeds(needs, machineCapabilities()),
+      remote,
+      planOnly: !!r.plan_only,
+      before: afterHold(r),
+      auto: autoHold(r.workspace_id, !!r.plan_only),
+      any,
+    },
+  };
+}
+
+// A paused task that came due, as a candidate to score against new arrivals.
+export function resumeCandidate(d: DueResume): Candidate {
+  const workspaceId = workspaceOf(d.projectId);
+  return {
+    id: `resume:${d.sessionId}`,
+    kind: "resume",
+    group: groupKey(workspaceId, d.projectId),
+    priority: d.priority,
+    position: -1_000_000 + d.pauseId,
+    waitingSinceMs: d.dueAtMs,
+    heavy: false,
+    needsUnmet: false,
+    remote: false,
+    before: null,
+    // A person's timed resume goes ahead of an orchestrator Pause.
+    auto: d.byKind === "person" ? null : autoHold(workspaceId),
+    any: null,
+  };
+}
+
+// A deliberate resume starts past the slot limit; only a red machine holds
+// it, and the task says so.
+export async function forceDueResumes(due: DueResume[]): Promise<void> {
+  for (const d of due.filter((x) => x.resumeBy)) {
+    const s = sessionOf(d.sessionId);
+    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 });
+  }
+}
+
+// Each line's running count and limit, for the lines the candidates are in.
+export function buildGroups(
+  candidates: Candidate[],
+  rows: QueueRowWithWorkspace[],
+  resumes: DueResume[]
+): Map<string, Group> {
+  const groups = new Map<string, Group>();
+  for (const c of candidates) {
+    if (groups.has(c.group)) continue;
+    const r = rows.find(
+      (x) => groupKey(x.workspace_id, x.project_id) === c.group
+    );
+    const projectId =
+      r?.project_id ??
+      resumes.find((d) => `resume:${d.sessionId}` === c.id)!.projectId;
+    const workspaceId = r?.workspace_id ?? workspaceOf(projectId);
+    groups.set(
+      c.group,
+      groupFor(
+        workspaceId,
+        projectId,
+        rows.filter(
+          (x) =>
+            x.status === "starting" &&
+            groupKey(x.workspace_id, x.project_id) === c.group
+        ).length
+      )
+    );
+  }
+  return groups;
+}

package/lib/tasks/queue-placement.ts

@@ -0,0 +1,155 @@
+/**
+ * Placing starts on linked machines: which machines could take which task,
+ * then the best machine for each start this one's load rules out, best score
+ * first, one per machine per look. The rules are pure, in placement.ts.
+ */
+
+import { getProject } from "../projects";
+import { hostLink, linkedHostIds } from "../hosts/remote-api";
+import { peerReading, peerSource, refreshPeers } from "../hosts/peer-load";
+import { projectMachines } from "../hosts/project-machines";
+import { viewOf } from "../load/machines";
+import { usesGitCrypt } from "../worktree-add";
+import { hostTasks } from "./remote";
+import {
+  asPlanPhase,
+  place,
+  unplaceable,
+  wantsPlacing,
+  type Need,
+  type PeerOption,
+  type Placement,
+} from "./placement";
+import { scoreParts, type Candidate, type MachineView } from "./schedule";
+import { expandHome } from "./session";
+import { orchestratorOf } from "./starter";
+import { lineSignature, row } from "./queue-rows";
+import type { QueueRow, QueueRowWithWorkspace } from "./queue-types";
+
+// A plan placed elsewhere may have to come back here to be built, and a
+// git-crypt repository never leaves this machine (the key stays here).
+function placementBarred(r: Pick<QueueRow, "project_id">): boolean {
+  const project = getProject(r.project_id);
+  return !project || usesGitCrypt(expandHome(project.working_directory));
+}
+
+// The linked machines a task could be placed on, with what they report.
+async function peerOptions(
+  rows: QueueRowWithWorkspace[],
+  now: number
+): Promise<Map<string, PeerOption[]>> {
+  const out = new Map<string, PeerOption[]>();
+  const hostIds = [...linkedHostIds()];
+  if (!hostIds.length || !rows.length) return out;
+  await refreshPeers(hostIds, now);
+  // Whether each machine can hold an orchestrator's task (an older AgentOS
+  // can't, and would fail its start); unreadable counts as no.
+  const holds = new Map<string, boolean>();
+  const plans = new Map<string, boolean>();
+  await Promise.all(
+    hostIds.map(async (hostId) => {
+      const link = hostLink(hostId);
+      const caps = link
+        ? await hostTasks(link)
+            .then((t) => t.capabilities ?? [])
+            .catch(() => [])
+        : [];
+      holds.set(hostId, caps.includes("held-start"));
+      plans.set(hostId, caps.includes("remote-plan"));
+    })
+  );
+  const perProject = new Map<string, Record<string, string | null>>();
+  for (const r of rows) {
+    if (out.has(r.project_id)) continue;
+    const project = getProject(r.project_id);
+    let can: Record<string, string | null> = {};
+    if (project) {
+      can =
+        perProject.get(project.id) ??
+        (await projectMachines(project).catch(() => ({})));
+      perProject.set(project.id, can);
+    }
+    out.set(
+      r.project_id,
+      hostIds.map((hostId) => {
+        const src = peerSource(hostId, now);
+        const reading = peerReading(hostId);
+        return {
+          hostId,
+          name: src.label,
+          view: viewOf(src, now),
+          capabilities: src.capabilities,
+          holds: holds.get(hostId) ?? false,
+          plans: plans.get(hostId) ?? false,
+          hasProject: can[hostId] === null,
+          loadPerCore: reading ? reading.load1 / reading.cores : 99,
+        };
+      })
+    );
+  }
+  return out;
+}
+
+// A start that plans first goes by its plan phase: it needs no Mac or
+// simulator, and a plan-only one that no machine can take starts here
+// as ever (it never waits on load).
+const plansFirst = (r: QueueRow) => !!(r.plan || r.plan_only);
+
+// Marks each start the home machine's load rules out as remote and returns
+// where it goes. "stale": the line moved while the machines were asked, so
+// this look is over, and the one a change during it asks for sees the line
+// as it is now.
+export async function placeCandidates(
+  candidates: Candidate[],
+  rows: QueueRowWithWorkspace[],
+  needsOf: Map<string, Need[]>,
+  home: MachineView,
+  now: number
+): Promise<Map<string, Placement> | "stale"> {
+  const placements = new Map<string, Placement>();
+  const asked = (c: Candidate) => {
+    const r = row(c.id)!;
+    return plansFirst(r) ? asPlanPhase(c) : c;
+  };
+  const toPlace = candidates.filter((c) => {
+    if (c.kind !== "start" || c.remote) return false;
+    const r = row(c.id)!;
+    if (unplaceable(r)) return false;
+    if (plansFirst(r) && placementBarred(r)) return false;
+    return wantsPlacing(asked(c), home, now);
+  });
+  if (!toPlace.length) return placements;
+  const before = lineSignature();
+  const peers = await peerOptions(
+    toPlace.map((c) => rows.find((r) => r.id === c.id)!),
+    now
+  );
+  if (lineSignature() !== before) return "stale";
+  const taken = new Set<string>();
+  for (const c of [...toPlace].sort(
+    (a, b) =>
+      scoreParts(b, now).score - scoreParts(a, now).score ||
+      a.position - b.position
+  )) {
+    const r = rows.find((x) => x.id === c.id)!;
+    const plan = plansFirst(r);
+    const options = (peers.get(r.project_id) ?? []).filter(
+      (p) =>
+        !taken.has(p.hostId) &&
+        (!orchestratorOf(r.started_by) || p.holds !== false) &&
+        (!plan || p.plans)
+    );
+    const spot = place(
+      asked(c),
+      home,
+      options,
+      plan ? [] : (needsOf.get(c.id) ?? []),
+      now
+    );
+    if (!spot) continue;
+    taken.add(spot.hostId);
+    placements.set(c.id, spot);
+    c.remote = true;
+  }
+  return placements;
+}

package/lib/tasks/queue-rows.ts

@@ -0,0 +1,236 @@
+/**
+ * The line's rows and slot counts: the small reads and writes everything else
+ * in the queue builds on.
+ */
+
+import { db, type Session } from "../db";
+import { getProject } from "../projects";
+import { getWorkspace } from "../workspaces";
+import { queuedLabel } from "./queue-held";
+import type { Group } from "./schedule";
+import type { QueueRow } from "./queue-types";
+
+export const IN_FLIGHT = ["running", "moving"];
+
+export const row = (id: string) =>
+  db.prepare(`SELECT * FROM task_queue WHERE id = ?`).get(id) as
+    | QueueRow
+    | undefined;
+
+export const sessionOf = (id: string) =>
+  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+
+export function patch(id: string, fields: Partial<QueueRow>): void {
+  const keys = Object.keys(fields);
+  if (!keys.length) return;
+  db.prepare(
+    `UPDATE task_queue SET ${keys.map((k) => `${k} = @${k}`).join(", ")} WHERE id = @id`
+  ).run({ ...fields, id });
+}
+
+export const workspaceOf = (projectId: string) =>
+  getProject(projectId)?.workspace_id ?? null;
+
+// Direct starts under way, by workspace: their task rows don't exist until
+// createTask gets that far, so they hold their slot here meanwhile.
+// On globalThis: the custom server's watcher and the route bundles each load
+// their own copy of this module, and must see one set of reservations.
+const g = globalThis as unknown as {
+  __agentosQueueReserved?: Map<string, number>;
+};
+export const reserved = (g.__agentosQueueReserved ??= new Map<
+  string,
+  number
+>());
+
+// Running tasks hold their slot until they finish (merged, dropped, done),
+// PR open or not; a queued task being started counts too. A paused task
+// gives its slot back until it resumes. A quick change
+// runs no agent, so it holds none. Without a
+// workspace, the project is the scope.
+export function runningIn(
+  scope: { workspaceId: string | null; projectId: string },
+  forSlots = false
+) {
+  const where = scope.workspaceId
+    ? `p.workspace_id = @ws`
+    : `p.id = @project AND p.workspace_id IS NULL`;
+  return (
+    db
+      .prepare(
+        `SELECT s.id FROM sessions s JOIN projects p ON p.id = s.project_id
+         WHERE ${where} AND s.archived_at IS NULL AND s.quick_of IS NULL
+           AND (s.pause_state IS NULL OR s.pause_state != 'paused')
+           ${forSlots ? `AND NOT (COALESCE(s.plan_only, 0) = 1 AND COALESCE(s.plan_phase, '') != 'implementing')` : ""}
+           AND s.task_status IN (${IN_FLIGHT.map((s) => `'${s}'`).join(", ")})`
+      )
+      .all({ ws: scope.workspaceId, project: scope.projectId }) as {
+      id: string;
+    }[]
+  ).map((r) => r.id);
+}
+
+export function startingIn(workspaceId: string): number {
+  return (
+    (reserved.get(workspaceId) ?? 0) +
+    (
+      db
+        .prepare(
+          `SELECT COUNT(*) AS n FROM task_queue q JOIN projects p ON p.id = q.project_id
+         WHERE q.status = 'starting' AND p.workspace_id = ?
+           AND q.plan_only IS NULL`
+        )
+        .get(workspaceId) as { n: number }
+    ).n
+  );
+}
+
+export const limitOf = (workspaceId: string | null) =>
+  workspaceId ? (getWorkspace(workspaceId)?.max_running_tasks ?? null) : null;
+
+// Finished, as far as a wait on it goes: merged, dropped, done or handed to
+// another machine, or a queued task that was removed or failed to start.
+export function hasFinished(taskId: string): boolean {
+  const s = sessionOf(taskId);
+  if (s) return !!s.archived_at || !IN_FLIGHT.includes(s.task_status ?? "");
+  const q = row(taskId);
+  return !q || (q.status !== "queued" && q.status !== "starting");
+}
+
+// Still something to wait for under "any": in flight, and not a task whose
+// PR was closed or merged and which nobody finished (that one never will).
+export function stillWorking(taskId: string): boolean {
+  if (hasFinished(taskId)) return false;
+  const s = sessionOf(taskId);
+  return !s || (s.pr_status !== "closed" && s.pr_status !== "merged");
+}
+
+export function afterMet(r: QueueRow): boolean {
+  if (r.after_task && !hasFinished(r.after_task)) return false;
+  if (r.after_any && !r.after_any_used) {
+    const ids = JSON.parse(r.after_any) as string[];
+    if (ids.length && !ids.some((id) => !stillWorking(id))) return false;
+  }
+  return true;
+}
+
+// A task named by id, id prefix or name, running or queued; in one
+// workspace when given (the orchestrator's).
+export function resolveAfter(
+  ref: string,
+  workspaceId: string | null
+): { id: string; name: string } {
+  const want = ref.trim();
+  const lower = want.toLowerCase();
+  const scope = workspaceId ? `AND p.workspace_id = @ws` : "";
+  const candidates = db
+    .prepare(
+      `SELECT s.id, s.name FROM sessions s JOIN projects p ON p.id = s.project_id
+       WHERE s.archived_at IS NULL AND s.task_status IN ('running', 'moving') ${scope}
+       UNION ALL
+       SELECT q.id, COALESCE(q.name, q.prompt) AS name FROM task_queue q
+         JOIN projects p ON p.id = q.project_id
+       WHERE q.status IN ('queued', 'starting') ${scope}`
+    )
+    .all({ ws: workspaceId }) as { id: string; name: string }[];
+  const exact = candidates.filter(
+    (c) => c.id === want || c.name.toLowerCase() === lower
+  );
+  const hits = exact.length
+    ? exact
+    : want.length >= 4
+      ? candidates.filter((c) => c.id.startsWith(want))
+      : [];
+  if (hits.length === 1) return hits[0];
+  if (hits.length > 1)
+    throw new Error(
+      `"${ref}" matches ${hits.length} tasks: ${hits.map((h) => `${h.name} (${h.id.slice(0, 8)})`).join(", ")}`
+    );
+  throw new Error(`No running or queued task matches "${ref}"`);
+}
+
+// How full the workspace's running-task limit is for this project.
+export function slotState(projectId: string): {
+  running: number;
+  limit: number | null;
+  full: boolean;
+} {
+  const workspaceId = workspaceOf(projectId);
+  const limit = limitOf(workspaceId);
+  if (!workspaceId || limit === null)
+    return { running: 0, limit: null, full: false };
+  const running =
+    runningIn({ workspaceId, projectId }, true).length +
+    startingIn(workspaceId);
+  return { running, limit, full: running >= limit };
+}
+
+export const waitingIn = (workspaceId: string) =>
+  (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM task_queue q JOIN projects p ON p.id = q.project_id
+         WHERE q.status = 'queued' AND p.workspace_id = ?
+           AND q.after_task IS NULL AND q.after_any IS NULL
+           AND q.plan_only IS NULL`
+      )
+      .get(workspaceId) as { n: number }
+  ).n;
+
+export const label = queuedLabel;
+
+export function afterLabel(r: QueueRow): string | null {
+  if (r.after_task) {
+    const s = sessionOf(r.after_task);
+    const q = s ? null : row(r.after_task);
+    return s?.name ?? (q ? label(q) : r.after_task.slice(0, 8));
+  }
+  return r.after_any ? "any running task" : null;
+}
+
+// SQLite's datetime('now') is UTC without a zone.
+export const sqliteMs = (v: string) =>
+  Date.parse(v.includes("T") ? v : `${v.replace(" ", "T")}Z`) || 0;
+
+export const groupKey = (workspaceId: string | null, projectId: string) =>
+  workspaceId ?? `project:${projectId}`;
+
+export function groupFor(
+  workspaceId: string | null,
+  projectId: string,
+  startingRows: number
+): Group {
+  const scope = { workspaceId, projectId };
+  return {
+    inFlight:
+      runningIn(scope, true).length +
+      (workspaceId ? (reserved.get(workspaceId) ?? 0) : 0) +
+      startingRows,
+    limit: limitOf(workspaceId) ?? Number.POSITIVE_INFINITY,
+  };
+}
+
+// Finishes other waiters have taken, so one finish lets one waiter go.
+export const usedFinishes = (): string[] =>
+  (
+    db
+      .prepare(
+        `SELECT after_any_used AS id FROM task_queue WHERE after_any_used IS NOT NULL`
+      )
+      .all() as { id: string }[]
+  ).map((x) => x.id);
+
+export function lineSignature(): string {
+  const r = db
+    .prepare(
+      `SELECT COUNT(*) AS n, COALESCE(MAX(position), 0) AS p,
+              COALESCE(SUM(priority = 'normal'), 0) AS pr,
+              (SELECT COUNT(*) FROM sessions WHERE task_status IS NOT NULL
+                 AND task_status NOT IN ('merged', 'dropped')) AS running
+       FROM task_queue WHERE status IN ('queued', 'starting')`
+    )
+    .get() as { n: number; p: number; pr: number; running: number };
+  return `${r.n}:${r.p}:${r.pr}:${r.running}`;
+}