@saadnvd1/agent-os 0.3.577 → 0.3.579

package/components/SessionList/SessionRowMenu.tsx

@@ -268,7 +268,7 @@ export function SessionRowMenu({
           {summarizing ? "Summarizing..." : "Fresh start"}
         </Item>
       )}
-      {(session.role === "orchestrator" || session.has_brief) &&
+      {(session.role === "orchestrator" || !!session.has_brief) &&
         session.view === "chat" &&
         !session.archived_at &&
         !blocked && (

package/lib/bus/index.ts

@@ -17,6 +17,12 @@ import { tmuxPane } from "./tmux-pane";
 import { hostLink } from "../hosts/remote-api";
 import { pauseHoldOf, pausedNote } from "../tasks/pause-hold";
 import { relayToHeldTask } from "../tasks/held-remote";
+import {
+  assertTakesMessages,
+  findQueuedTarget,
+  heldQueuedNote,
+  type QueuedTarget,
+} from "../tasks/queue-held";
 import { heldOrchestrator, heldTarget } from "./held-reply";
 import { HUMAN, overRateLimit, wakeLine, type BusMessageView } from "./format";
 
@@ -115,13 +121,29 @@ export function resolveTarget(ref: string): {
   session: Session;
   note?: string;
 } {
+  const found = tryResolveTarget(ref);
+  if (!found.ok) throw new Error(found.error);
+  return found;
+}
+
+function tryResolveTarget(
+  ref: string
+):
+  | { ok: true; session: Session; note?: string }
+  | { ok: false; none: boolean; error: string } {
   const sessions = liveSessions();
   const r = resolveRef(ref, candidates(sessions));
   if (!r.ok)
-    throw new Error(
-      r.reason === "none" ? `${r.error}. Run: aos peers` : r.error
-    );
-  return { session: sessions.find((s) => s.id === r.id)!, note: r.note };
+    return {
+      ok: false,
+      none: r.reason === "none",
+      error: r.reason === "none" ? `${r.error}. Run: aos peers` : r.error,
+    };
+  return {
+    ok: true,
+    session: sessions.find((s) => s.id === r.id)!,
+    note: r.note,
+  };
 }
 
 export function resolveSession(ref: string): Session {
@@ -252,7 +274,13 @@ export async function sendMessage(opts: {
   // A message pulled from a linked machine, by its key there: one already
   // stored is not stored or delivered again.
   relayKey?: string;
-}): Promise<{ message: BusMessageView; delivery: Delivery; note?: string }> {
+}): Promise<{
+  message: BusMessageView;
+  delivery: Delivery;
+  note?: string;
+  // The task it was held for, when that task is still in the start queue.
+  heldForQueued?: boolean;
+}> {
   const body = opts.body.trim();
   if (!body) throw new Error("Message is empty");
   const from = sessionById(opts.fromId);
@@ -260,7 +288,14 @@ export async function sendMessage(opts: {
   // A held task's message to its orchestrator is kept for the holder to pull.
   const held = heldTarget(from, opts.to);
   if (from && held) return storeForHolder(from, held, body);
-  const { session: to, note } = resolveTarget(opts.to);
+  const target = tryResolveTarget(opts.to);
+  if (!target.ok) {
+    // A task still in the start queue has no session yet: hold it.
+    const queued = target.none ? findQueuedTarget(opts.to) : null;
+    if (!queued) throw new Error(target.error);
+    return storeForQueued(from, opts.fromLabel, queued, body, opts.relayKey);
+  }
+  const { session: to, note } = target;
   if (from && from.id === to.id)
     throw new Error("A session can't message itself");
   if (from && overRateLimit(pairTimestamps(from.id, to.id))) {
@@ -355,6 +390,45 @@ function storeForHolder(
   };
 }
 
+// A message for a task that hasn't started: kept with the queued task and
+// delivered in its first prompt. A schedule's `line` is only a wake line;
+// the body is what's held.
+function storeForQueued(
+  from: Session | undefined,
+  fromLabel: string | undefined,
+  to: QueuedTarget,
+  body: string,
+  relayKey?: string
+) {
+  assertTakesMessages(to);
+  if (from && overRateLimit(pairTimestamps(from.id, to.id)))
+    throw new Error(
+      `Too many messages between ${from.name} and ${to.name}; wait a few minutes`
+    );
+  const { lastInsertRowid } = db
+    .prepare(
+      `INSERT INTO bus_messages (from_id, from_name, to_id, to_name, body, relay_key, held_queued)
+       VALUES (?, ?, ?, ?, ?, ?, 1)`
+    )
+    .run(
+      from?.id ?? null,
+      from?.name ?? fromLabel ?? HUMAN,
+      to.id,
+      to.name,
+      body,
+      relayKey ?? null
+    );
+  const message = toView(
+    db.prepare(`${SELECT} WHERE m.id = ?`).get(Number(lastInsertRowid)) as Row
+  );
+  return {
+    message,
+    delivery: { state: "queued" as const },
+    note: heldQueuedNote(to.name),
+    heldForQueued: true,
+  };
+}
+
 // Unread messages for a session, marked read as they're returned.
 export function readInbox(sessionId: string): BusMessageView[] {
   const rows = db

package/lib/db/migrations.ts

@@ -2242,6 +2242,25 @@ export const migrations: Migration[] = [
       `);
     },
   },
+  {
+    key: "20261014T1600_queued_task_messages",
+    up: (db) => {
+      // A message for a task still in the start queue, held (addressed to
+      // the queue id, which is the session id it starts as) until its
+      // first prompt. Additive.
+      const has = (
+        db.prepare(`PRAGMA table_info(bus_messages)`).all() as {
+          name: string;
+        }[]
+      ).some((c) => c.name === "held_queued");
+      if (!has)
+        db.exec(`ALTER TABLE bus_messages ADD COLUMN held_queued INTEGER`);
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_bus_messages_held_queued
+           ON bus_messages(to_id) WHERE held_queued = 1`
+      );
+    },
+  },
 ];
 
 // `upTo`: stop after this legacy id or timestamp key, inclusive (tests that

package/lib/orchestrator/act.ts

@@ -40,6 +40,12 @@ import { braked } from "./brakes";
 import { getOrchestrator } from "./home";
 import { addNote } from "./notes";
 import { findWorkspaceSession } from "./read";
+import {
+  assertTakesMessages,
+  findQueuedTarget,
+  heldQueuedNote,
+  type QueuedTarget,
+} from "../tasks/queue-held";
 import { workspaceProject, workspaceStack, workspaceTask } from "./targets";
 import { setPriority, stampPriority } from "../tasks/queue";
 import {
@@ -68,7 +74,15 @@ export async function send(
   message: string,
   opts: { scopeChange?: boolean } = {}
 ): Promise<string> {
-  const to = findWorkspaceSession(workspaceId, ref);
+  let to;
+  try {
+    to = findWorkspaceSession(workspaceId, ref);
+  } catch (error) {
+    // A task still in the queue has no session: it holds the message.
+    const queued = findQueuedTarget(ref, { workspaceId });
+    if (!queued) throw error;
+    return sendToQueued(workspaceId, queued, message, opts);
+  }
   let amended = "";
   if (opts.scopeChange) {
     if (to.task_status !== "running")
@@ -96,6 +110,32 @@ export async function send(
     : `Delivered to ${to.name}.${amended}`;
 }
 
+// A queued task's id is the session id it starts as, so the amendment
+// recorded under it is already the running task's.
+async function sendToQueued(
+  workspaceId: string,
+  queued: QueuedTarget,
+  message: string,
+  opts: { scopeChange?: boolean }
+): Promise<string> {
+  assertTakesMessages(queued);
+  let amended = "";
+  if (opts.scopeChange) {
+    amendBrief(workspaceId, queued.id, message);
+    addNote(workspaceId, `Scope change for ${queued.name}: ${message}`);
+    amended = ` Recorded as scope change ${amendmentsOf(queued.id).length} on its brief: reviews judge against it once it has a PR.`;
+  }
+  const sent = await sendMessage({
+    fromId: orchestratorId(workspaceId),
+    to: queued.id,
+    body: message,
+  });
+  // It may have started in between: then it was delivered as to any task.
+  return sent.heldForQueued
+    ? `${heldQueuedNote(queued.name)}${amended}`
+    : `Delivered to ${queued.name}.${amended}`;
+}
+
 // What the orchestrator starts opens as a chat, as a new session in the UI
 // does (one default, in launch.ts); terminal is for a job that needs a TUI.
 export { DEFAULT_START_VIEW, type StartView };

package/lib/orchestrator/digest.ts

@@ -218,6 +218,8 @@ function queueSection(workspaceId: string): Section {
   const rows = db
     .prepare(
       `SELECT q.id, q.name, q.prompt, q.status, q.after_task, q.after_any, q.priority, q.note,
+         (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,
          p.name AS project, a.name AS after_name
        FROM task_queue q JOIN projects p ON p.id = q.project_id
        LEFT JOIN sessions a ON a.id = q.after_task
@@ -235,6 +237,7 @@ function queueSection(workspaceId: string): Section {
     after_name: string | null;
     priority: string;
     note: string | null;
+    held: number;
   }[];
   return {
     title: "Queued tasks, in line order",
@@ -246,8 +249,11 @@ function queueSection(workspaceId: string): Section {
           : "";
       const status = r.status === "queued" ? "" : ` | ${r.status}`;
       const priority = r.priority === "normal" ? "" : ` | ${r.priority}`;
+      const held = r.held
+        ? ` | ${r.held} held message${r.held === 1 ? "" : "s"}`
+        : "";
       const why = r.note ? ` | ${clip(r.note, 100)}` : "";
-      return `- ${i + 1}. ${clip(r.name ?? r.prompt, 80)} (${r.project}, id ${shortId(r.id)})${after}${priority}${status}${why}`;
+      return `- ${i + 1}. ${clip(r.name ?? r.prompt, 80)} (${r.project}, id ${shortId(r.id)})${after}${priority}${status}${held}${why}`;
     }),
     more: "the sessions tool",
   };

package/lib/orchestrator/tools.ts

@@ -56,7 +56,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   read: "The end of one session's terminal or chat, or an external session's screen, as plain text (capped at about 4k tokens).",
   cards: "Cards on this workspace's linked LumifyHub boards, by list.",
   logs: "Session logs AgentOS wrote when tasks merged: the last N headers (task, PR, cost, duration) of the workspace or one project, or one log in full (brief, plan, timeline, usage, outcome). Read straight from the database; nothing is summarised.",
-  send: "Message a session in this workspace over the bus. It arrives as its next prompt. When Saad changes a running task's scope, tell it with scope_change set, so its review judges the PR against the brief as amended.",
+  send: "Message a session in this workspace over the bus. It arrives as its next prompt. When Saad changes a running task's scope, tell it with scope_change set, so its review judges the PR against the brief as amended. A task still in the queue (by id or name) takes messages too: they are held and reach it with its first prompt; scope_change on one records the change on its brief at once.",
   orchestrators:
     "Every workspace, and whether it has an orchestrator you can message.",
   message_orchestrator:

package/lib/sidebar/queued.ts

@@ -78,7 +78,13 @@ export function queuedSubtitle(item: QueuedTaskView): {
   if (item.after) return { lead: "After", after: item.after };
   const priority =
     item.priority === "normal" ? "" : ` · ${PRIORITY_LABEL[item.priority]}`;
-  return { lead: `#${item.rank} of ${item.of}${priority}`, after: null };
+  const held = item.held
+    ? ` · ${item.held} message${item.held === 1 ? "" : "s"} held`
+    : "";
+  return {
+    lead: `#${item.rank} of ${item.of}${priority}${held}`,
+    after: null,
+  };
 }
 
 // The priority choices for a waiting task's menu, the current one marked.

package/lib/tasks/queue-held.ts

@@ -0,0 +1,115 @@
+/**
+ * Messages for a task still in the start queue. They're ordinary bus
+ * messages addressed to the queue id (the id the task starts as), flagged
+ * held_queued, and reach the task in its first prompt (tasks/start.ts).
+ * Nothing is deleted: a delivered or discarded message is marked, like the
+ * ones held for a paused task.
+ *
+ * Light on purpose: the message bus imports this, and must not pull in the
+ * queue's scheduler.
+ */
+
+import { db } from "../db";
+import type { HeldMessage } from "./pause-policy";
+
+export function queuedLabel(r: { name: string | null; 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;
+}
+
+export interface QueuedTarget {
+  id: string;
+  name: string;
+  status: string;
+  error: string | null;
+}
+
+// A task waiting to start (or failed to) by id, id prefix of 4+ characters
+// or name; in one workspace when given.
+export function findQueuedTarget(
+  ref: string,
+  opts: { workspaceId?: string } = {}
+): QueuedTarget | null {
+  const want = ref.trim();
+  if (!want) return null;
+  const rows = db
+    .prepare(
+      `SELECT q.id, q.name, q.prompt, q.status, q.error, p.name AS project
+       FROM task_queue q JOIN projects p ON p.id = q.project_id
+       WHERE q.status IN ('queued', 'starting', 'failed')
+         ${opts.workspaceId ? "AND p.workspace_id = @ws" : ""}`
+    )
+    .all(opts.workspaceId ? { ws: opts.workspaceId } : {}) as {
+    id: string;
+    name: string | null;
+    prompt: string;
+    status: string;
+    error: string | null;
+    project: string;
+  }[];
+  const lower = want.toLowerCase();
+  const hits = rows.filter((r) => {
+    const name = queuedLabel(r).toLowerCase();
+    return (
+      r.id === want ||
+      (want.length >= 4 && r.id.startsWith(want)) ||
+      name === lower ||
+      `${r.project}/${name}`.toLowerCase() === lower
+    );
+  });
+  if (hits.length > 1)
+    throw new Error(
+      `"${ref}" matches ${hits.length} queued tasks: ${hits.map((h) => `${queuedLabel(h)} (${h.id.slice(0, 8)})`).join(", ")}`
+    );
+  const r = hits[0];
+  return r
+    ? { id: r.id, name: queuedLabel(r), status: r.status, error: r.error }
+    : null;
+}
+
+// Refuses a task that failed to start: nothing will ever start it.
+export function assertTakesMessages(q: QueuedTarget): void {
+  if (q.status === "failed")
+    throw new Error(
+      `${q.name} failed to start${q.error ? ` (${q.error})` : ""}; it takes no messages. Remove it and queue it again.`
+    );
+}
+
+export const heldQueuedNote = (name: string) =>
+  `Queued for ${name}: it hasn't started; it gets this when it starts.`;
+
+const UNDELIVERED = `held_queued = 1 AND delivered_at IS NULL AND read_at IS NULL`;
+
+export function queuedHeldMessages(id: string): HeldMessage[] {
+  return (
+    db
+      .prepare(
+        `SELECT from_name, body FROM bus_messages
+         WHERE to_id = ? AND ${UNDELIVERED} ORDER BY id`
+      )
+      .all(id) as { from_name: string; body: string }[]
+  ).map((r) => ({ from: r.from_name, text: r.body }));
+}
+
+// They're in the first prompt: delivered, and not for `aos inbox` again.
+export function markQueuedHeldDelivered(id: string): void {
+  db.prepare(
+    `UPDATE bus_messages
+     SET delivered_at = datetime('now'), read_at = COALESCE(read_at, datetime('now'))
+     WHERE to_id = ? AND ${UNDELIVERED}`
+  ).run(id);
+}
+
+// The task left the queue without starting.
+export function discardQueuedHeld(id: string): void {
+  db.prepare(
+    `UPDATE bus_messages SET read_at = datetime('now')
+     WHERE to_id = ? AND ${UNDELIVERED}`
+  ).run(id);
+}
+
+export function queuedMessagesSection(held: HeldMessage[]): string {
+  if (!held.length) return "";
+  return `\n\n## Messages while queued\nThese arrived before you started, oldest first. They are part of your instructions:\n${held.map((m, i) => `${i + 1}. From ${m.from}: ${m.text}`).join("\n")}`;
+}

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,
@@ -148,6 +155,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 +428,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 +443,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 +453,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 +497,7 @@ export function listQueue(): QueuedTaskView[] {
       wait: r.wait_code,
       rank: rank?.rank ?? place,
       of: rank?.of ?? place,
+      held: r.held_count,
     };
   });
 }
@@ -635,10 +644,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 +681,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(),
@@ -1077,7 +1091,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 +1119,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/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.577",
+  "version": "0.3.579",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"