@saadnvd1/agent-os 0.3.457 → 0.3.459

package/components/Workspaces/WorkspaceSettings.tsx

@@ -2,6 +2,8 @@
 
 import { useWorkspacesQuery } from "@/data/workspaces";
 import { TaskLimitForm } from "./TaskLimitForm";
+import { RulesForm } from "./RulesForm";
+import { FreshStartForm } from "./FreshStartForm";
 
 // Settings > Workspaces: each workspace's own settings.
 export function WorkspaceSettings() {
@@ -36,8 +38,10 @@ export function WorkspaceSettings() {
             key={`${w.id}:${w.max_running_tasks ?? "off"}`}
             workspace={w}
           />
+          <RulesForm workspaceId={w.id} />
         </section>
       ))}
+      <FreshStartForm />
     </div>
   );
 }

package/components/Workspaces/fresh-start.ts

@@ -0,0 +1,19 @@
+import {
+  MAX_REFRESH_TOKENS,
+  MIN_REFRESH_TOKENS,
+} from "@/lib/chat/refresh-limits";
+
+// A threshold's input, in thousands of tokens: off is 0; on takes a whole
+// number in the range the server holds (lib/chat/refresh).
+export function parseFreshStart(
+  on: boolean,
+  text: string
+): { tokens: number } | { error: string } {
+  if (!on) return { tokens: 0 };
+  const k = Number(text.trim());
+  const min = MIN_REFRESH_TOKENS / 1000;
+  const max = MAX_REFRESH_TOKENS / 1000;
+  if (!text.trim() || !Number.isInteger(k) || k < min || k > max)
+    return { error: `A whole number from ${min} to ${max}` };
+  return { tokens: k * 1000 };
+}

package/data/chat/useChat.ts

@@ -18,6 +18,7 @@ import type {
   ToolBody,
   UndoPreview,
 } from "@/lib/chat/events";
+import type { SearchResult } from "@/lib/chat/find";
 
 // The index of the item with `id`, searched from the end: what changes is
 // almost always the latest.
@@ -147,6 +148,9 @@ export function useChat(
   const fileRequests = useRef(
     new Map<string, (files: FileSuggestion[]) => void>()
   );
+  const searchRequests = useRef(
+    new Map<string, (result: SearchResult) => void>()
+  );
   const [taskOutputs, setTaskOutputs] = useState<Record<string, string | null>>(
     {}
   );
@@ -215,6 +219,9 @@ export function useChat(
         } else if (m.type === "files") {
           fileRequests.current.get(m.reqId)?.(m.files);
           fileRequests.current.delete(m.reqId);
+        } else if (m.type === "search") {
+          searchRequests.current.get(m.reqId)?.(m);
+          searchRequests.current.delete(m.reqId);
         } else if (m.type === "state") {
           setState(m.state);
         } else if (m.type === "capabilities") {
@@ -393,6 +400,27 @@ export function useChat(
     });
   }, []);
 
+  // A page of find's results from the stored conversation, newest first;
+  // null when the socket is down or no answer comes (a linked machine's
+  // AgentOS too old to search).
+  const search = useCallback((query: string, before?: number) => {
+    const ws = wsRef.current;
+    if (!ws || ws.readyState !== WebSocket.OPEN)
+      return Promise.resolve<SearchResult | null>(null);
+    const reqId = Math.random().toString(36).slice(2);
+    return new Promise<SearchResult | null>((resolve) => {
+      const timer = setTimeout(() => {
+        searchRequests.current.delete(reqId);
+        resolve(null);
+      }, 10_000);
+      searchRequests.current.set(reqId, (result) => {
+        clearTimeout(timer);
+        resolve(result);
+      });
+      ws.send(JSON.stringify({ type: "search", reqId, query, before }));
+    });
+  }, []);
+
   const loadTaskOutput = useCallback((taskId: string) => {
     wsRef.current?.send(JSON.stringify({ type: "task_output", taskId }));
   }, []);
@@ -451,5 +479,6 @@ export function useChat(
     queueSendNow,
     suggestion,
     requestFiles,
+    search,
   };
 }

package/data/fresh-start/index.ts

@@ -0,0 +1,34 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { RefreshSettings } from "@/lib/chat/refresh";
+
+// When chats start a fresh conversation (lib/chat/refresh).
+export const freshStartKeys = { all: ["fresh-start"] as const };
+
+async function json<T>(res: Response): Promise<T> {
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || `Request failed (${res.status})`);
+  return data;
+}
+
+export function useFreshStartQuery() {
+  return useQuery({
+    queryKey: freshStartKeys.all,
+    queryFn: async () => json<RefreshSettings>(await fetch("/api/fresh-start")),
+    staleTime: 60000,
+  });
+}
+
+export function useUpdateFreshStart() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (settings: Partial<RefreshSettings>) =>
+      json<RefreshSettings>(
+        await fetch("/api/fresh-start", {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(settings),
+        })
+      ),
+    onSuccess: (data) => queryClient.setQueryData(freshStartKeys.all, data),
+  });
+}

package/data/orchestrators/rules.ts

@@ -0,0 +1,80 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { RuleRow } from "@/lib/orchestrator/rules";
+import { provePresence } from "../presence";
+
+// A workspace orchestrator's standing rules (lib/orchestrator/rules).
+// Pushed when the table changes (data/push/topics).
+export const ruleKeys = {
+  all: ["orchestrator-rules"] as const,
+  list: (workspaceId: string) => [...ruleKeys.all, workspaceId] as const,
+};
+
+const url = (workspaceId: string, ruleId?: number) =>
+  `/api/workspaces/${workspaceId}/orchestrator/rules${ruleId ? `/${ruleId}` : ""}`;
+
+async function call<T>(input: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(input, {
+    ...init,
+    headers: { "Content-Type": "application/json" },
+  }).catch(() => {
+    throw new Error("Couldn't reach AgentOS, so this may not be saved.");
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || `Request failed (${res.status})`);
+  return data;
+}
+
+export function useRulesQuery(workspaceId: string) {
+  return useQuery({
+    queryKey: ruleKeys.list(workspaceId),
+    queryFn: async () =>
+      (await call<{ rules: RuleRow[] }>(url(workspaceId))).rules,
+    staleTime: 30000,
+  });
+}
+
+function useRuleMutation<V>(
+  workspaceId: string,
+  request: (v: V) => Promise<unknown>
+) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: request,
+    onSettled: () =>
+      queryClient.invalidateQueries({ queryKey: ruleKeys.list(workspaceId) }),
+  });
+}
+
+// A rule written here is Saad's word to the orchestrator: each change
+// takes his passkey.
+const proven = async (workspaceId: string, body: object = {}) =>
+  JSON.stringify({
+    ...body,
+    assertion: await provePresence({ purpose: "rules", workspaceId }),
+  });
+
+export const useAddRule = (workspaceId: string) =>
+  useRuleMutation(workspaceId, async (text: string) =>
+    call(url(workspaceId), {
+      method: "POST",
+      body: await proven(workspaceId, { text }),
+    })
+  );
+
+export const useUpdateRule = (workspaceId: string) =>
+  useRuleMutation(
+    workspaceId,
+    async ({ id, text }: { id: number; text: string }) =>
+      call(url(workspaceId, id), {
+        method: "PATCH",
+        body: await proven(workspaceId, { text }),
+      })
+  );
+
+export const useRemoveRule = (workspaceId: string) =>
+  useRuleMutation(workspaceId, async (id: number) =>
+    call(url(workspaceId, id), {
+      method: "DELETE",
+      body: await proven(workspaceId),
+    })
+  );

package/data/push/topics.ts

@@ -8,6 +8,7 @@ import { devServerKeys } from "../dev-servers/keys";
 import { busKeys } from "../bus";
 import { stackKeys } from "../stacks";
 import { orchestratorKeys } from "../orchestrators";
+import { ruleKeys } from "../orchestrators/rules";
 import { workspaceKeys } from "../workspaces";
 import { scheduleKeys } from "../schedules";
 import { archivedKeys } from "../done";
@@ -53,6 +54,8 @@ function keysFor(topic: string): QueryKey[] {
       return [scheduleKeys.all];
     case "orchestrator_asks":
       return [orchestratorKeys.all];
+    case "orchestrator_rules":
+      return [ruleKeys.all];
     case "dev_servers":
       return [devServerKeys.all];
     default:
@@ -92,6 +95,7 @@ export const ALL_TOPICS = [
   "bus_messages",
   "schedules",
   "orchestrator_asks",
+  "orchestrator_rules",
   "dev_servers",
 ];
 

package/lib/chat/demo.ts

@@ -72,6 +72,7 @@ export const DEMO_CHAT_READS = new Set<ChatClientMessage["type"]>([
   "history",
   "tool_body",
   "task_output",
+  "search",
 ]);
 
 /**

package/lib/chat/events.ts

@@ -1,3 +1,5 @@
+import type { SearchResult } from "./find";
+
 /**
  * The provider-neutral shape of a chat conversation. Every driver (Claude
  * today, others later) turns its own protocol into these items; storage,
@@ -300,6 +302,8 @@ export type ChatServerMessage =
       hasMore: boolean;
     }
   | { type: "tool_body"; id: string; body: ToolBody | null }
+  // Find in the conversation: one page of results for the request `reqId`.
+  | ({ type: "search"; reqId: string; query: string } & SearchResult)
   | { type: "queue"; queue: QueuedMessage[] }
   | { type: "suggestion"; text: string | null }
   | {
@@ -348,4 +352,6 @@ export type ChatClientMessage =
   | { type: "task_output"; taskId: string }
   // Older items, from before a page's cursor.
   | { type: "history"; before: number }
-  | { type: "tool_body"; id: string };
+  | { type: "tool_body"; id: string }
+  // Older results from before `before`, a cursor from an earlier page.
+  | { type: "search"; reqId: string; query: string; before?: number };

package/lib/chat/find.ts

@@ -0,0 +1,278 @@
+/**
+ * Find in a conversation: what text each item lets a reader find (what its
+ * row shows once opened), where a match sits in it, and which rows to open to
+ * show it. Shared by the server's search and the panel's find bar, so both
+ * count the same matches.
+ */
+
+import type { ChatItem } from "./events";
+import { lineDiff } from "./diff";
+import { groupTimeline, STANDALONE_TOOLS, type ToolItem } from "./group";
+import { eventParts, originOf } from "./origin";
+
+export const MIN_QUERY = 2;
+export const MAX_QUERY = 200;
+
+// Whether `query` could be in a diff at all, before paying for lineDiff.
+const inDiff = (diff: NonNullable<ToolItem["diff"]>, query: string) => {
+  const q = query.toLowerCase();
+  return (
+    diff.before.toLowerCase().includes(q) ||
+    diff.after.toLowerCase().includes(q)
+  );
+};
+
+function toolText(tool: ToolItem, query?: string): string {
+  if (tool.name === "Skill") return tool.title;
+  const input = (tool.input ?? {}) as Record<string, unknown>;
+  if (STANDALONE_TOOLS.has(tool.name))
+    return [tool.title, input.prompt, tool.output].filter(Boolean).join("\n");
+  const parts = [tool.title];
+  if (tool.diff && query !== undefined && !inDiff(tool.diff, query))
+    parts.push(tool.diff.path);
+  else if (tool.diff)
+    parts.push(
+      tool.diff.path,
+      ...lineDiff(tool.diff.before, tool.diff.after).map((l) => l.text)
+    );
+  else {
+    parts.push(
+      tool.name === "Bash" && typeof input.command === "string"
+        ? input.command
+        : JSON.stringify(tool.input, null, 2)
+    );
+    if (tool.output) parts.push(tool.output);
+  }
+  return parts.join("\n");
+}
+
+// What a reader can find in an item: its row's text, opened. Nothing for
+// items the timeline doesn't show. With `query`, a diff it can't be in is
+// left out rather than laid out line by line.
+export function findableText(item: ChatItem, query?: string): string {
+  switch (item.kind) {
+    case "user": {
+      const origin = originOf(item);
+      if (!origin) return item.text;
+      const { body, decided } = eventParts(item, origin);
+      return [...decided, body].join("\n");
+    }
+    case "assistant":
+    case "reasoning":
+    case "command_output":
+    case "note":
+      return item.text;
+    case "plan":
+      return item.plan;
+    case "error":
+      return item.message;
+    case "todos":
+      return item.todos.map((t) => t.text).join("\n");
+    case "artifact":
+      return item.title;
+    case "approval":
+      // A settled one is told by its tool call (lib/chat/group).
+      if (
+        item.status !== "pending" &&
+        !(item.status === "answered" && item.questions)
+      )
+        return "";
+      return [item.title, ...(item.questions ?? []).map((q) => q.question)]
+        .filter(Boolean)
+        .join("\n");
+    case "tool":
+      return toolText(item, query);
+    default:
+      return "";
+  }
+}
+
+// Where `query` occurs in `text`, case-insensitively and not overlapping.
+export function occurrences(text: string, query: string): number[] {
+  const q = query.toLowerCase();
+  if (!q) return [];
+  const t = text.toLowerCase();
+  const at: number[] = [];
+  for (let i = t.indexOf(q); i !== -1; i = t.indexOf(q, i + q.length))
+    at.push(i);
+  return at;
+}
+
+export interface Snippet {
+  before: string;
+  match: string;
+  after: string;
+}
+
+// A line's worth around a match, for a result list or a log.
+export function snippetAt(
+  text: string,
+  at: number,
+  length: number,
+  around = 40
+): Snippet {
+  const flat = (s: string) => s.replace(/\s+/g, " ");
+  const start = Math.max(0, at - around);
+  const end = Math.min(text.length, at + length + around);
+  return {
+    before: (start > 0 ? "…" : "") + flat(text.slice(start, at)).trimStart(),
+    match: flat(text.slice(at, at + length)),
+    after:
+      flat(text.slice(at + length, end)).trimEnd() +
+      (end < text.length ? "…" : ""),
+  };
+}
+
+export interface SearchHit {
+  id: string;
+  seq: number;
+  // Matches in this item, in the order its row shows them.
+  count: number;
+  snippet: Snippet;
+}
+
+export interface SearchResult {
+  // Matches in the whole conversation, up to MAX_MATCHES.
+  total: number;
+  capped: boolean;
+  // Items with a match, newest first, older than the asked-for cursor.
+  hits: SearchHit[];
+  // The oldest hit's position: the next page asks from before it.
+  cursor: number | null;
+  hasMore: boolean;
+}
+
+export interface Located {
+  // The timeline block to scroll to.
+  block: string;
+  // Row states to open, outermost first (components/Chat/rowState).
+  open: string[];
+}
+
+function rowKeys(item: ChatItem): string[] {
+  if (item.kind === "reasoning") return [`reasoning:${item.id}`];
+  if (item.kind === "tool" && STANDALONE_TOOLS.has(item.name))
+    return item.name === "Skill" ? [] : [`agent:${item.id}`];
+  if (item.kind === "user") {
+    const origin = originOf(item);
+    if (!origin) return [];
+    const { decided } = eventParts(item, origin);
+    return [
+      `event:${item.id}`,
+      ...decided.map((_, i) => `event:${item.id}:${i}`),
+    ];
+  }
+  return [];
+}
+
+/**
+ * Which block of the loaded timeline shows an item, and which rows to open
+ * so it's on screen: a step inside its folded run, a message inside an undo.
+ * Null when it isn't loaded (or the timeline never shows it).
+ */
+export function locate(items: ChatItem[], id: string): Located | null {
+  const at = items.findIndex((i) => i.id === id);
+  if (at === -1) return null;
+  const inside = (
+    blocks: ReturnType<typeof groupTimeline>,
+    open: string[]
+  ): Omit<Located, "block"> | null => {
+    for (const b of blocks) {
+      if (b.type === "item" && b.item.id === id)
+        return { open: [...open, ...rowKeys(b.item)] };
+      if (b.type === "tools" && b.tools.some((t) => t.id === id))
+        return { open: [...open, `steps:${b.id}`, `tool:${id}`] };
+      if (b.type === "undone" && b.items.some((i) => i.id === id))
+        return (
+          inside(groupTimeline(b.items), [...open, `undone:${b.undo.id}`]) ?? {
+            open: [...open, `undone:${b.undo.id}`],
+          }
+        );
+    }
+    return null;
+  };
+  const blocks = groupTimeline(items);
+  const blockOf = (b: (typeof blocks)[number]) =>
+    b.type === "item" ? b.item.id : b.id;
+  for (const b of blocks) {
+    const found = inside([b], []);
+    if (found) return { block: blockOf(b), ...found };
+  }
+  // Reasoning between steps folds out of sight: the run it sits in.
+  for (let i = at - 1; i >= 0; i--) {
+    const before = items[i];
+    if (before.kind !== "tool") continue;
+    const run = blocks.find(
+      (b) => b.type === "tools" && b.tools.some((t) => t.id === before.id)
+    );
+    if (run) return { block: blockOf(run), open: [`steps:${blockOf(run)}`] };
+    break;
+  }
+  return null;
+}
+
+// One match to go to: the item, and which of its matches (in its own order).
+export interface FindTarget {
+  id: string;
+  n: number;
+}
+
+// Results newest first, as the reader meets them scrolling up from the end:
+// an item's last match before its first.
+export function flattenHits(hits: SearchHit[]): FindTarget[] {
+  return hits.flatMap((h) =>
+    Array.from({ length: h.count }, (_, i) => ({
+      id: h.id,
+      n: h.count - 1 - i,
+    }))
+  );
+}
+
+/**
+ * Where next (+1, older) or previous (-1, newer) goes from `index` among
+ * `loaded` results: "more" when the next is on a page not fetched yet. It
+ * wraps around only once every result is loaded.
+ */
+export function stepIndex(
+  index: number,
+  dir: 1 | -1,
+  loaded: number,
+  hasMore: boolean
+): number | "more" {
+  if (!loaded) return 0;
+  const next = index + dir;
+  if (next >= loaded) return hasMore ? "more" : 0;
+  if (next < 0) return hasMore ? 0 : loaded - 1;
+  return next;
+}
+
+// Results walked so far: the first page's count, then every page's hits.
+export interface FindResults extends SearchResult {
+  query: string;
+}
+
+// Pages on from `before` until one has a hit (a page that read only a slice
+// of a huge conversation may have none) or there are no more.
+export async function nextHits(
+  search: (query: string, before?: number) => Promise<SearchResult | null>,
+  query: string,
+  before: number | null,
+  maxPages = 100
+): Promise<SearchResult | null> {
+  let page = await search(query, before ?? undefined);
+  for (
+    let i = 1;
+    page && !page.hits.length && page.hasMore && i < maxPages;
+    i++
+  )
+    page = await search(query, page.cursor ?? undefined);
+  return page;
+}
+
+// Older hits joined on; the count and its cap stay the first page's.
+export const joinPage = (r: FindResults, page: SearchResult): FindResults => ({
+  ...r,
+  hits: r.hits.concat(page.hits),
+  hasMore: page.hasMore,
+  cursor: page.cursor,
+});

package/lib/chat/refresh-limits.ts

@@ -0,0 +1,5 @@
+// The range a fresh-start threshold may take (lib/chat/refresh), shared
+// with the settings form. Below the minimum a fresh brief and digest alone
+// could be most of the budget.
+export const MIN_REFRESH_TOKENS = 50_000;
+export const MAX_REFRESH_TOKENS = 900_000;

package/lib/chat/refresh.ts

@@ -0,0 +1,82 @@
+/**
+ * Fresh starts: a chat whose context passes a threshold ends its agent's
+ * conversation at the next turn boundary, and the next worker starts a new
+ * one with the brief (lib/chat/worker/host). An orchestrator is fed events
+ * nonstop, never idles and can't compact itself, so it's on for it by
+ * default: its state is in the database and its brief carries it
+ * (lib/orchestrator/digest). A task keeps its progress only in its
+ * conversation and its branch, so for tasks it's off unless switched on.
+ * App-wide, in Settings → Workspaces.
+ */
+
+import { db } from "../db";
+import { MAX_REFRESH_TOKENS, MIN_REFRESH_TOKENS } from "./refresh-limits";
+
+export const ORCHESTRATOR_KEY = "orchestrator.refresh_tokens";
+export const TASK_KEY = "chat.task_refresh_tokens";
+export const DEFAULT_ORCHESTRATOR_TOKENS = 200_000;
+export { MIN_REFRESH_TOKENS, MAX_REFRESH_TOKENS } from "./refresh-limits";
+
+export interface RefreshSettings {
+  // Context tokens at which a conversation starts over; 0 is off.
+  orchestratorTokens: number;
+  taskTokens: number;
+}
+
+function read(key: string, fallback: number): number {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(key) as { value: string } | undefined;
+  const n = row ? Number(row.value) : fallback;
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+
+export function refreshSettings(): RefreshSettings {
+  return {
+    orchestratorTokens: read(ORCHESTRATOR_KEY, DEFAULT_ORCHESTRATOR_TOKENS),
+    taskTokens: read(TASK_KEY, 0),
+  };
+}
+
+// A threshold, checked: 0 (off) or a whole number in range. Throws a plain
+// message otherwise.
+export function checkRefreshTokens(value: unknown): number {
+  if (value === 0) return 0;
+  if (
+    typeof value !== "number" ||
+    !Number.isInteger(value) ||
+    value < MIN_REFRESH_TOKENS ||
+    value > MAX_REFRESH_TOKENS
+  )
+    throw new Error(
+      `A fresh-start threshold is off or between ${MIN_REFRESH_TOKENS / 1000}k and ${MAX_REFRESH_TOKENS / 1000}k tokens`
+    );
+  return value;
+}
+
+export function setRefreshSettings(input: Partial<RefreshSettings>): void {
+  const put = db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  );
+  const checked: [string, number][] = [];
+  if (input.orchestratorTokens !== undefined)
+    checked.push([
+      ORCHESTRATOR_KEY,
+      checkRefreshTokens(input.orchestratorTokens),
+    ]);
+  if (input.taskTokens !== undefined)
+    checked.push([TASK_KEY, checkRefreshTokens(input.taskTokens)]);
+  db.transaction(() => {
+    for (const [key, n] of checked) put.run(key, String(n));
+  })();
+}
+
+const k = (tokens: number) => `${Math.round(tokens / 1000)}k`;
+
+// What the agent reads ahead of its first message in the new conversation.
+export function refreshedNote(role: "orchestrator" | "task", tokens: number) {
+  return role === "orchestrator"
+    ? `(AgentOS started you on a fresh conversation: the last one passed ${k(tokens)} tokens of context. Your brief and "Where things stand" are current; carry on from them.)`
+    : `(AgentOS started you on a fresh conversation: the last one passed ${k(tokens)} tokens of context. Your brief is above; check git status, git log and your PR to see how far you got, then carry on.)`;
+}

package/lib/chat/runner.ts

@@ -226,8 +226,10 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
           registry.live.delete(sessionId);
           emit(sessionId, { type: "state", state: "idle" });
         }
-        // It retired itself for a current worker: what it queued goes now.
-        if (live?.retireSent) resumed.delete(sessionId);
+        // It retired itself for a current worker, or ended its agent's
+        // conversation at the context threshold: what it queued goes now.
+        if (live?.retireSent || refreshedAway(sessionId))
+          resumed.delete(sessionId);
         // Its agent died mid-turn, with messages still queued, or with a
         // turn cut off. (One this server let go, it stopped on purpose.)
         if (live && !detached)
@@ -375,6 +377,13 @@ export function deleteQueuedChat(sessionId: string, id: string) {
   emitQueue(sessionId);
 }
 
+const refreshedAway = (sessionId: string) =>
+  !!(
+    db
+      .prepare(`SELECT chat_refreshed FROM sessions WHERE id = ?`)
+      .get(sessionId) as { chat_refreshed: number } | undefined
+  )?.chat_refreshed;
+
 // A queue no worker is left to send (it was retired, or its agent died):
 // a fresh worker sends it in order. Never interrupts: a worker that's busy
 // sends its queue when its turn ends. At most once a minute per