@saadnvd1/agent-os 0.3.578 → 0.3.580

package/lib/tasks/queue.ts

@@ -31,6 +31,13 @@ import {
 import { queueEvent } from "../orchestrator/events";
 import { readUsage, windowRefusal } from "../orchestrator/usage";
 import { createTask } from "./index";
+import {
+  discardQueuedHeld,
+  markQueuedHeldDelivered,
+  queuedHeldMessages,
+  queuedLabel,
+  queuedMessagesSection,
+} from "./queue-held";
 import { expandHome } from "./session";
 import {
   DEFAULT_PRIORITY,
@@ -67,7 +74,8 @@ import {
   viewOf,
 } from "../load/machines";
 import { peerReading, peerSource, refreshPeers } from "../hosts/peer-load";
-import { linkedHostIds } from "../hosts/remote-api";
+import { hostLink, linkedHostIds } from "../hosts/remote-api";
+import { hostTasks } from "./remote";
 import { projectMachines } from "../hosts/project-machines";
 import { claimResume, dueResumes } from "./pause";
 
@@ -148,6 +156,8 @@ export interface QueuedTaskView {
   // Its place in the score order within its line, and how many are in it.
   rank: number;
   of: number;
+  // Messages held for it until it starts.
+  held: number;
 }
 
 export const START_ATTEMPTS = 3;
@@ -419,11 +429,7 @@ export async function startOrQueue<T>(
   }
 }
 
-function label(r: Pick<QueueRow, "name" | "prompt">): string {
-  if (r.name) return r.name;
-  const line = r.prompt.split("\n")[0].trim();
-  return line.length > 60 ? `${line.slice(0, 57)}...` : line;
-}
+const label = queuedLabel;
 
 function afterLabel(r: QueueRow): string | null {
   if (r.after_task) {
@@ -438,7 +444,9 @@ function afterLabel(r: QueueRow): string | null {
 export function listQueue(): QueuedTaskView[] {
   const rows = db
     .prepare(
-      `SELECT q.*, p.name AS project_name, p.workspace_id AS workspace_id
+      `SELECT q.*, p.name AS project_name, p.workspace_id AS workspace_id,
+         (SELECT COUNT(*) FROM bus_messages b WHERE b.to_id = q.id
+            AND b.held_queued = 1 AND b.delivered_at IS NULL AND b.read_at IS NULL) AS held_count
        FROM task_queue q LEFT JOIN projects p ON p.id = q.project_id
        WHERE q.status IN ('queued', 'starting', 'failed')
        ORDER BY q.position`
@@ -446,6 +454,7 @@ export function listQueue(): QueuedTaskView[] {
     .all() as (QueueRow & {
     project_name: string | null;
     workspace_id: string | null;
+    held_count: number;
   })[];
   const places = new Map<string, number>();
   // The score order within each line, by priority and age alone: holds
@@ -489,6 +498,7 @@ export function listQueue(): QueuedTaskView[] {
       wait: r.wait_code,
       rank: rank?.rank ?? place,
       of: rank?.of ?? place,
+      held: r.held_count,
     };
   });
 }
@@ -635,10 +645,14 @@ async function startRow(
   const placed = opts.placement ?? null;
   if (!opts.force)
     recordAutoStart(placed?.hostId ?? LOCAL, !!opts.heavy, Date.now());
+  // A linked machine's start never sees this machine's held messages: they
+  // go with the brief it is sent.
+  const remote = isRemoteHost(placed?.hostId ?? r.host_id ?? project?.host_id);
+  const remoteHeld = remote ? queuedHeldMessages(r.id) : [];
   const task = {
     id: r.id,
     projectId: r.project_id,
-    prompt: r.prompt,
+    prompt: r.prompt + queuedMessagesSection(remoteHeld),
     name: r.name ?? undefined,
     model: r.model_overrides
       ? (JSON.parse(r.model_overrides) as ModelOverride)
@@ -668,6 +682,7 @@ async function startRow(
           { spendApproval: false }
         )
       : await createTask(task);
+    if (remoteHeld.length) markQueuedHeldDelivered(r.id);
     patch(r.id, {
       status: "started",
       started_at: new Date().toISOString(),
@@ -815,6 +830,20 @@ async function peerOptions(
   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>();
+  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"));
+    })
+  );
   const perProject = new Map<string, Record<string, string | null>>();
   for (const r of rows) {
     if (out.has(r.project_id)) continue;
@@ -836,6 +865,7 @@ async function peerOptions(
           name: src.label,
           view: viewOf(src, now),
           capabilities: src.capabilities,
+          holds: holds.get(hostId) ?? false,
           hasProject: can[hostId] === null,
           loadPerCore: reading ? reading.load1 / reading.cores : 99,
         };
@@ -911,7 +941,7 @@ export async function tickOnce(now = Date.now()): Promise<"stale" | void> {
     )) {
       const r = rows.find((x) => x.id === c.id)!;
       const options = (peers.get(r.project_id) ?? []).filter(
-        (p) => !taken.has(p.hostId)
+        (p) => !taken.has(p.hostId) && (!r.started_by || p.holds !== false)
       );
       const spot = place(c, home, options, built.get(c.id)!.needs, now);
       if (!spot) continue;
@@ -1077,7 +1107,7 @@ export function findQueued(
   return hits[0] ?? null;
 }
 
-export const queuedLabel = label;
+export { queuedLabel };
 
 // Changes the priority of a queued task or a running one (they share an
 // id). Age is kept. Throws when no such task is waiting or running.
@@ -1105,11 +1135,15 @@ export function stampPriority(id: string, priority: Priority | undefined) {
 }
 
 export function removeQueued(id: string): void {
-  const changed = db
-    .prepare(
-      `UPDATE task_queue SET status = 'removed' WHERE id = ? AND status IN ('queued', 'failed')`
-    )
-    .run(id).changes;
+  const changed = db.transaction(() => {
+    const n = db
+      .prepare(
+        `UPDATE task_queue SET status = 'removed' WHERE id = ? AND status IN ('queued', 'failed')`
+      )
+      .run(id).changes;
+    if (n) discardQueuedHeld(id);
+    return n;
+  })();
   if (!changed) throw new Error("That task isn't waiting in the queue");
   tickQueueSoon();
 }

package/lib/tasks/remote.ts

@@ -15,6 +15,7 @@ import {
 } from "../hosts/remote-api";
 import { isRemoteHost } from "../hosts";
 import { projectRef } from "./project-ref";
+import { orchestratedStart } from "./held";
 import type { TaskStatus } from "./state";
 import type { TaskView } from "./index";
 
@@ -33,6 +34,9 @@ export const TASK_CAPABILITIES = [
   // A held task's chat facts and its messages for its orchestrator.
   "held-chat-facts",
   "held-replies",
+  // A keyed start that carries an orchestrator's description holds the task
+  // for the device that sent it, as a move does (lib/tasks/held.ts).
+  "held-start",
 ] as const;
 
 export interface HostTasks {
@@ -48,7 +52,8 @@ export function isMirror(session: Session): boolean {
 export function mirrorTask(
   hostId: string,
   projectId: string | null,
-  remote: Session
+  remote: Session,
+  startedBy?: string | null
 ): void {
   db.prepare(
     `INSERT INTO sessions (id, name, tmux_name, working_directory, model, group_path,
@@ -71,6 +76,35 @@ export function mirrorTask(
     // As that machine runs it: one that predates chat tasks says terminal.
     remote.view === "chat" ? "chat" : "terminal"
   );
+  // What carryTaskState gives a moved task's mirror: the orchestrator that
+  // holds it, and when it began (so its PR is judged from then).
+  if (startedBy)
+    db.prepare(
+      `UPDATE sessions SET started_by = COALESCE(started_by, ?),
+         task_since = COALESCE(task_since, created_at) WHERE id = ?`
+    ).run(startedBy, remote.id);
+}
+
+/**
+ * A machine on an older AgentOS would take a chat task as a terminal one,
+ * or an orchestrator's task as a plain one that anyone there could merge, or
+ * refuse to hand one over.
+ */
+export async function requireCapability(
+  link: HostLink,
+  capability: string,
+  what: string,
+  verb = "move"
+): Promise<void> {
+  const { capabilities = [] } = await hostTasks(link, true).catch((err) => {
+    throw new Error(
+      `Can't ask ${link.hostName} whether it takes ${what}: ${(err as Error).message}`
+    );
+  });
+  if (!capabilities.includes(capability))
+    throw new Error(
+      `${link.hostName}'s AgentOS can't ${verb} ${what} yet; update it first`
+    );
 }
 
 export const unknownOutcome = (err: unknown) =>
@@ -101,16 +135,30 @@ export async function startRemoteTask(
     model?: string;
     baseBranch?: string;
     view?: "chat" | "terminal";
+    // The orchestrator that started it: that machine holds the task for it.
+    startedBy?: string | null;
   }
 ): Promise<Session> {
   const link = requireHostLink(hostId);
+  const { startedBy, ...rest } = opts;
+  if (startedBy)
+    await requireCapability(
+      link,
+      "held-start",
+      "an orchestrator's task",
+      "hold"
+    );
   const { session } = await postIdempotent<{ session: Session }>(
     link,
     "/api/tasks",
-    { project: await projectRef(project), ...opts },
+    {
+      project: await projectRef(project),
+      ...rest,
+      orchestrated: startedBy ? orchestratedStart(startedBy) : undefined,
+    },
     180000
   );
-  mirrorTask(hostId, project.id, session);
+  mirrorTask(hostId, project.id, session, startedBy);
   forgetHostTasks(hostId);
   return db
     .prepare(`SELECT * FROM sessions WHERE id = ?`)

package/lib/tasks/start.ts

@@ -28,6 +28,11 @@ import { planPrompt, preparePlanDir } from "../models/plan-step";
 
 export { firstMessageId, launchPending };
 import { expandHome } from "./session";
+import {
+  markQueuedHeldDelivered,
+  queuedHeldMessages,
+  queuedMessagesSection,
+} from "./queue-held";
 import {
   enterStage,
   finishSetup,
@@ -138,7 +143,12 @@ export async function finishTaskStart(
       ms: setup.ms,
       error: "Not launched: the task was closed during setup",
     });
-  const task = (session.task_prompt ?? "") + setupNote(setup);
+  // Messages sent while it waited in the queue follow the brief, in order.
+  const heldMessages = queuedHeldMessages(sessionId);
+  const task =
+    (session.task_prompt ?? "") +
+    queuedMessagesSection(heldMessages) +
+    setupNote(setup);
   const planning = session.plan_phase === "planning";
   if (planning) preparePlanDir(session.worktree_path);
   const prompt = planning ? planPrompt(task, !!session.plan_only) : task;
@@ -169,6 +179,7 @@ export async function finishTaskStart(
     );
     return done({ status: "failed", ms: setup.ms, error: message });
   }
+  if (heldMessages.length) markQueuedHeldDelivered(sessionId);
   return done(setup);
 }
 
@@ -237,6 +248,7 @@ export async function resumeTaskStarts(
         : fs.existsSync(promptFileFor(row.id)) && (await alive(row.tmux_name));
     if (launched) {
       recordSetup(db, row.id, { status: "ok", ms: null, error: null });
+      markQueuedHeldDelivered(row.id);
       if (queued)
         inBackground(`first message of task ${row.id}`, () =>
           sendQueuedNow(row.id, first)

package/package.json

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